libstore: remove Goal::WaitForWorld

have DerivationGoal and its subclasses produce a wrapper promise for
their intermediate results instead, and return this wrapper promise.
Worker already handles promises that do not complete immediately, so
we do not have to duplicate this into an entire result type variant.

Change-Id: Iae8dbf63cfc742afda4d415922a29ac5a3f39348

src/libstore/build/derivation-goal.cc

@@ -787,7 +787,7 @@ try {
                     buildResult.startTime = time(0); // inexact
                     state = &DerivationGoal::buildDone;
                     started();
-                    return {{WaitForWorld{std::move(a.promise)}}};
+                    return continueOrError(std::move(a.promise));
                 },
                 [&](HookReply::Postpone) -> std::optional<kj::Promise<Result<WorkResult>>> {
                     /* Not now; wait until at least one child finishes or
@@ -1756,4 +1756,17 @@ void DerivationGoal::waiteeDone(GoalPtr waitee)
     }
 }
 
+kj::Promise<Result<Goal::WorkResult>>
+DerivationGoal::continueOrError(kj::Promise<Outcome<void, Goal::Finished>> p)
+{
+    return p.then([](auto r) -> Result<WorkResult> {
+        if (r.has_value()) {
+            return ContinueImmediately{};
+        } else if (r.has_error()) {
+            return r.assume_error();
+        } else {
+            return r.assume_exception();
+        }
+    });
+}
 }

src/libstore/build/derivation-goal.hh

@@ -327,6 +327,8 @@ protected:
     Finished tooMuchLogs();
     void flushLine();
 
+    static kj::Promise<Result<WorkResult>> continueOrError(kj::Promise<Outcome<void, Goal::Finished>> p);
+
 public:
     /**
      * Wrappers around the corresponding Store methods that first consult the

src/libstore/build/drv-output-substitution-goal.cc

@@ -86,9 +86,7 @@ try {
         });
 
     state = &DrvOutputSubstitutionGoal::realisationFetched;
-    return {WaitForWorld{
-        pipe.promise.then([]() -> Outcome<void, Finished> { return result::success(); })
-    }};
+    return pipe.promise.then([]() -> Result<WorkResult> { return ContinueImmediately{}; });
 } catch (...) {
     return {std::current_exception()};
 }

src/libstore/build/goal.hh

@@ -115,9 +115,6 @@ public:
 
     struct [[nodiscard]] StillAlive {};
     struct [[nodiscard]] ContinueImmediately {};
-    struct [[nodiscard]] WaitForWorld {
-        kj::Promise<Outcome<void, Finished>> promise;
-    };
     struct [[nodiscard]] Finished {
         ExitCode exitCode;
         BuildResult result;
@@ -131,7 +128,6 @@ public:
     struct [[nodiscard]] WorkResult : std::variant<
                                           StillAlive,
                                           ContinueImmediately,
-                                          WaitForWorld,
                                           Finished>
     {
         WorkResult() = delete;

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

@@ -251,7 +251,7 @@ try {
         state = &DerivationGoal::buildDone;
 
         started();
-        return {WaitForWorld{std::move(promise)}};
+        return continueOrError(std::move(promise));
 
     } catch (BuildError & e) {
         outputLocks.unlock();

src/libstore/build/substitution-goal.cc

@@ -240,9 +240,7 @@ try {
     });
 
     state = &PathSubstitutionGoal::finished;
-    return {WaitForWorld{
-        pipe.promise.then([]() -> Outcome<void, Finished> { return result::success(); })
-    }};
+    return pipe.promise.then([]() -> Result<WorkResult> { return ContinueImmediately{}; });
 } catch (...) {
     return {std::current_exception()};
 }

src/libstore/build/worker.cc

@@ -202,17 +202,6 @@ void Worker::handleWorkResult(GoalPtr goal, Goal::WorkResult how)
         overloaded{
             [&](Goal::StillAlive) {},
             [&](Goal::ContinueImmediately) { wakeUp(goal); },
-            [&](Goal::WaitForWorld & w) {
-                childStarted(goal, w.promise.then([](auto r) -> Result<Goal::WorkResult> {
-                    if (r.has_value()) {
-                        return {Goal::ContinueImmediately{}};
-                    } else if (r.has_error()) {
-                        return {std::move(r).error()};
-                    } else {
-                        return r.exception();
-                    }
-                }));
-            },
             [&](Goal::Finished & f) { goalFinished(goal, f); },
         },
         how