libstore: remove DerivationOutput::CAFloating

nothing can create floating ca outputs any more.

Change-Id: Ic69f4a22066e1f5c0837f44e8d4fa2d93ca20ff6

lix/libstore/build/local-derivation-goal.cc

@@ -1739,14 +1739,14 @@ try {
             return res;
         };
 
-        auto newInfoFromCA = [&](const DerivationOutput::CAFloating outputHash) -> ValidPathInfo {
+        auto newInfoFromCA = [&](ContentAddressMethod method, HashType hashType) -> ValidPathInfo {
             auto st = get(outputStats, outputName);
             if (!st)
                 throw BuildError(
                     "output path %1% without valid stats info",
                     actualPath);
-            if (outputHash.method == ContentAddressMethod { FileIngestionMethod::Flat } ||
-                outputHash.method == ContentAddressMethod { TextIngestionMethod {} })
+            if (method == ContentAddressMethod { FileIngestionMethod::Flat } ||
+                method == ContentAddressMethod { TextIngestionMethod {} })
             {
                 /* The output path should be a regular file without execute permission. */
                 if (!S_ISREG(st->st_mode) || (st->st_mode & S_IXUSR) != 0)
@@ -1771,11 +1771,11 @@ try {
                     }
                     assert(false);
                 },
-            }, outputHash.method.raw);
-            auto got = computeHashModulo(outputHash.hashType, oldHashPart, input).first;
+            }, method.raw);
+            auto got = computeHashModulo(hashType, oldHashPart, input).first;
 
             auto optCA = ContentAddressWithReferences::fromPartsOpt(
-                outputHash.method,
+                method,
                 std::move(got),
                 rewriteRefs());
             if (!optCA) {
@@ -1840,10 +1840,7 @@ try {
                 movePath(actualPath, tmpOutput);
                 copyFile(tmpOutput, actualPath, { .deleteAfter = true });
 
-                auto newInfo0 = newInfoFromCA(DerivationOutput::CAFloating {
-                    .method = dof.ca.method,
-                    .hashType = wanted.type,
-                });
+                auto newInfo0 = newInfoFromCA(dof.ca.method, wanted.type);
 
                 /* Check wanted hash */
                 assert(newInfo0.ca);
@@ -1882,10 +1879,6 @@ try {
                 return newInfo0;
             },
 
-            [&](const DerivationOutput::CAFloating & dof) {
-                return newInfoFromCA(dof);
-            },
-
             [&](const DerivationOutput::Deferred &) -> ValidPathInfo {
                 // No derivation should reach that point without having been
                 // rewritten first

lix/libstore/derivations.cc

@@ -25,9 +25,6 @@ std::optional<StorePath> DerivationOutput::path(const Store & store, std::string
                 dof.path(store, drvName, outputName)
             };
         },
-        [](const DerivationOutput::CAFloating & dof) -> std::optional<StorePath> {
-            return std::nullopt;
-        },
         [](const DerivationOutput::Deferred &) -> std::optional<StorePath> {
             return std::nullopt;
         },
@@ -444,11 +441,6 @@ std::string Derivation::unparse(const Store & store, bool maskOutputs,
                 s += ','; printUnquotedString(s, dof.ca.printMethodAlgo());
                 s += ','; printUnquotedString(s, dof.ca.hash.to_string(Base::Base16, false));
             },
-            [&](const DerivationOutput::CAFloating & dof) {
-                s += ','; printUnquotedString(s, "");
-                s += ','; printUnquotedString(s, dof.method.renderPrefix() + printHashType(dof.hashType));
-                s += ','; printUnquotedString(s, "");
-            },
             [&](const DerivationOutput::Deferred &) {
                 s += ','; printUnquotedString(s, "");
                 s += ','; printUnquotedString(s, "");
@@ -521,9 +513,7 @@ DerivationType BasicDerivation::type() const
     std::set<std::string_view>
         inputAddressedOutputs,
         fixedCAOutputs,
-        floatingCAOutputs,
         deferredIAOutputs;
-    std::optional<HashType> floatingHashType;
 
     for (auto & i : outputs) {
         std::visit(overloaded {
@@ -533,15 +523,6 @@ DerivationType BasicDerivation::type() const
             [&](const DerivationOutput::CAFixed &) {
                 fixedCAOutputs.insert(i.first);
             },
-            [&](const DerivationOutput::CAFloating & 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");
-                }
-            },
             [&](const DerivationOutput::Deferred &) {
                 deferredIAOutputs.insert(i.first);
             },
@@ -550,13 +531,11 @@ DerivationType BasicDerivation::type() const
 
     if (inputAddressedOutputs.empty()
         && fixedCAOutputs.empty()
-        && floatingCAOutputs.empty()
         && deferredIAOutputs.empty())
         throw Error("must have at least one output");
 
     if (!inputAddressedOutputs.empty()
         && fixedCAOutputs.empty()
-        && floatingCAOutputs.empty()
         && deferredIAOutputs.empty())
         return DerivationType::InputAddressed {
             .deferred = false,
@@ -564,7 +543,6 @@ DerivationType BasicDerivation::type() const
 
     if (inputAddressedOutputs.empty()
         && !fixedCAOutputs.empty()
-        && floatingCAOutputs.empty()
         && deferredIAOutputs.empty())
     {
         if (fixedCAOutputs.size() > 1)
@@ -580,16 +558,6 @@ DerivationType BasicDerivation::type() const
 
     if (inputAddressedOutputs.empty()
         && fixedCAOutputs.empty()
-        && !floatingCAOutputs.empty()
-        && deferredIAOutputs.empty())
-        return DerivationType::ContentAddressed {
-            .sandboxed = true,
-            .fixed = false,
-        };
-
-    if (inputAddressedOutputs.empty()
-        && fixedCAOutputs.empty()
-        && floatingCAOutputs.empty()
         && !deferredIAOutputs.empty())
         return DerivationType::InputAddressed {
             .deferred = true,
@@ -800,11 +768,6 @@ void writeDerivation(Sink & out, const Store & store, const BasicDerivation & dr
                     << dof.ca.printMethodAlgo()
                     << dof.ca.hash.to_string(Base::Base16, false);
             },
-            [&](const DerivationOutput::CAFloating & dof) {
-                out << ""
-                    << (dof.method.renderPrefix() + printHashType(dof.hashType))
-                    << "";
-            },
             [&](const DerivationOutput::Deferred &) {
                 out << ""
                     << ""
@@ -1007,10 +970,6 @@ try {
                     return {result::current_exception()};
                 }
             },
-            [](const DerivationOutput::CAFloating &) -> kj::Promise<Result<void>> {
-                /* Nothing to check */
-                return {result::success()};
-            },
             [](const DerivationOutput::Deferred &) -> kj::Promise<Result<void>> {
                 /* Nothing to check */
                 return {result::success()};
@@ -1037,9 +996,6 @@ JSON DerivationOutput::toJSON(
             res["hash"] = dof.ca.hash.to_string(Base::Base16, false);
             // FIXME print refs?
         },
-        [&](const DerivationOutput::CAFloating & dof) {
-            res["hashAlgo"] = dof.method.renderPrefix() + printHashType(dof.hashType);
-        },
         [&](const DerivationOutput::Deferred &) {},
     }, raw);
     return res;

lix/libstore/derivations.hh

@@ -63,26 +63,6 @@ struct DerivationOutput
         GENERATE_CMP(CAFixed, me->ca);
     };
 
-    /**
-     * Floating-output derivations, whose output paths are content
-     * addressed, but not fixed, and so are dynamically calculated from
-     * whatever the output ends up being.
-     * */
-    struct CAFloating
-    {
-        /**
-         * How the file system objects will be serialized for hashing
-         */
-        ContentAddressMethod method;
-
-        /**
-         * How the serialization will be hashed
-         */
-        HashType hashType;
-
-        GENERATE_CMP(CAFloating, me->method, me->hashType);
-    };
-
     /**
      * Input-addressed output which depends on a (CA) derivation whose hash
      * isn't known yet.
@@ -94,7 +74,6 @@ struct DerivationOutput
     typedef std::variant<
         InputAddressed,
         CAFixed,
-        CAFloating,
         Deferred
     > Raw;