From 6756cecfcf266801219b1e2da7e79f14695ccecf Mon Sep 17 00:00:00 2001
From: John Ericson <John.Ericson@Obsidian.Systems>
Date: Fri, 17 Jul 2020 19:55:41 +0000
Subject: [PATCH] Add `DerivationType::CAFloating`

---
 src/libstore/derivations.cc | 28 +++++++++++++++++++++-------
 src/libstore/derivations.hh |  1 +
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc
index 487ed47e9..2a95c7e69 100644
--- a/src/libstore/derivations.cc
+++ b/src/libstore/derivations.cc
@@ -28,6 +28,7 @@ bool derivationIsCA(DerivationType dt) {
     switch (dt) {
     case DerivationType::Regular: return false;
     case DerivationType::CAFixed: return true;
+    case DerivationType::CAFloating: return true;
     };
     // Since enums can have non-variant values, but making a `default:` would
     // disable exhaustiveness warnings.
@@ -38,6 +39,7 @@ bool derivationIsFixed(DerivationType dt) {
     switch (dt) {
     case DerivationType::Regular: return false;
     case DerivationType::CAFixed: return true;
+    case DerivationType::CAFloating: return false;
     };
     abort();
 }
@@ -46,6 +48,7 @@ bool derivationIsImpure(DerivationType dt) {
     switch (dt) {
     case DerivationType::Regular: return false;
     case DerivationType::CAFixed: return true;
+    case DerivationType::CAFloating: return false;
     };
     abort();
 }
@@ -387,7 +390,8 @@ bool isDerivation(const string & fileName)
 
 DerivationType BasicDerivation::type() const
 {
-    std::set<std::string_view> inputAddressedOutputs, fixedCAOutputs;
+    std::set<std::string_view> inputAddressedOutputs, fixedCAOutputs, floatingCAOutputs;
+    std::optional<HashType> floatingHashType;
     for (auto & i : outputs) {
         std::visit(overloaded {
             [&](DerivationOutputInputAddressed _) {
@@ -396,23 +400,31 @@ DerivationType BasicDerivation::type() const
             [&](DerivationOutputFixed _) {
                 fixedCAOutputs.insert(i.first);
             },
-            [&](DerivationOutputFloating _) {
-                throw Error("Floating CA output derivations are not yet implemented");
+            [&](DerivationOutputFloating dof) {
+                floatingCAOutputs.insert(i.first);
+                if (!floatingHashType) {
+                    floatingHashType = dof.hashType;
+                } else {
+                    if (*floatingHashType != dof.hashType)
+                        throw Error("All floating outputs must use the same hash type");
+                }
             },
         }, i.second.output);
     }
 
-    if (inputAddressedOutputs.empty() && fixedCAOutputs.empty()) {
+    if (inputAddressedOutputs.empty() && fixedCAOutputs.empty() && floatingCAOutputs.empty()) {
         throw Error("Must have at least one output");
-    } else if (! inputAddressedOutputs.empty() && fixedCAOutputs.empty()) {
+    } else if (! inputAddressedOutputs.empty() && fixedCAOutputs.empty() && floatingCAOutputs.empty()) {
         return DerivationType::Regular;
-    } else if (inputAddressedOutputs.empty() && ! fixedCAOutputs.empty()) {
+    } else if (inputAddressedOutputs.empty() && ! fixedCAOutputs.empty() && floatingCAOutputs.empty()) {
         if (fixedCAOutputs.size() > 1)
             // FIXME: Experimental feature?
             throw Error("Only one fixed output is allowed for now");
         if (*fixedCAOutputs.begin() != "out")
             throw Error("Single fixed output must be named \"out\"");
         return DerivationType::CAFixed;
+    } else if (inputAddressedOutputs.empty() && fixedCAOutputs.empty() && ! floatingCAOutputs.empty()) {
+        return DerivationType::CAFloating;
     } else {
         throw Error("Can't mix derivation output types");
     }
@@ -464,6 +476,8 @@ DrvHashModulo hashDerivationModulo(Store & store, const Derivation & drv, bool m
 {
     /* Return a fixed hash for fixed-output derivations. */
     switch (drv.type()) {
+    case DerivationType::CAFloating:
+        throw Error("Regular input-addressed derivations are not yet allowed to depend on CA derivations");
     case DerivationType::CAFixed: {
         std::map<std::string, Hash> outputHashes;
         for (const auto & i : drv.outputs) {
@@ -476,7 +490,7 @@ DrvHashModulo hashDerivationModulo(Store & store, const Derivation & drv, bool m
         }
         return outputHashes;
     }
-    default:
+    case DerivationType::Regular:
         break;
     }
 
diff --git a/src/libstore/derivations.hh b/src/libstore/derivations.hh
index 45217b3d5..b8e2494a3 100644
--- a/src/libstore/derivations.hh
+++ b/src/libstore/derivations.hh
@@ -61,6 +61,7 @@ typedef std::map<string, string> StringPairs;
 enum struct DerivationType : uint8_t {
     Regular,
     CAFixed,
+    CAFloating,
 };
 
 /* Do the outputs of the derivation have paths calculated from their content,