Work around coroutine bug in GCC 13

Non-trivial control flow along with coroutines triggerse
an internal compiler error in GCC.

We avoid this by simplifying the control flow in which
`co_await`s and `co_return`s appear, by creating
variables that hold the coroutines, and then jumping to them.

This works because when calling a coroutine function,
it always suspends immediately, without executing any logic.

Author: L-as

src/libstore/build/derivation-goal.cc

@@ -116,19 +116,26 @@ void DerivationGoal::addWantedOutputs(const OutputsSpec & outputs)
     wantedOutputs = newWanted;
 }
 
+static Goal::Co empty_co() {
+    co_return Goal::Return{};
+}
 
 Goal::Co DerivationGoal::init() {
     trace("init");
 
+    Co gcc_bug_workaround{empty_co()};
+
+    if (useDerivation && (buildMode != bmNormal || !worker.evalStore.isValidPath(drvPath))) {
+        gcc_bug_workaround = await({upcast_goal(worker.makePathSubstitutionGoal(drvPath))});
+    }
+
+    co_await std::move(gcc_bug_workaround);
+
     if (useDerivation) {
         /* The first thing to do is to make sure that the derivation
            exists.  If it doesn't, it may be created through a
            substitute. */
 
-        if (buildMode != bmNormal || !worker.evalStore.isValidPath(drvPath)) {
-            co_await await({upcast_goal(worker.makePathSubstitutionGoal(drvPath))});
-        }
-
         trace("loading derivation");
 
         if (nrFailed != 0) {
@@ -410,6 +417,9 @@ Goal::Co DerivationGoal::gaveUpOnSubstitution()
 
     /* Determine the full set of input paths. */
 
+    // needed because of GCC bug
+    std::optional<std::pair<Co, Co>> gcc_bug_workaround{};
+
     /* First, the input derivations. */
     if (useDerivation) {
         auto & fullDrv = *dynamic_cast<Derivation *>(drv.get());
@@ -483,14 +493,10 @@ Goal::Co DerivationGoal::gaveUpOnSubstitution()
 
             resolvedDrvGoal = worker.makeDerivationGoal(
                 pathResolved, wantedOutputs, buildMode);
-            co_await await({resolvedDrvGoal});
 
-            co_return resolvedFinished();
-        }
-
-        /* If we get this far, we know no dynamic drvs inputs */
-
-        for (auto & [depDrvPath, depNode] : fullDrv.inputDrvs.map) {
+            gcc_bug_workaround = {await({resolvedDrvGoal}), resolvedFinished()};
+        } else for (auto & [depDrvPath, depNode] : fullDrv.inputDrvs.map) {
+            /* If we get this far, we know no dynamic drvs inputs */
             for (auto & outputName : depNode.value) {
                 /* Don't need to worry about `inputGoals`, because
                    impure derivations are always resolved above. Can
@@ -515,19 +521,27 @@ Goal::Co DerivationGoal::gaveUpOnSubstitution()
         }
     }
 
-    /* Second, the input sources. */
-    worker.store.computeFSClosure(drv->inputSrcs, inputPaths);
+    bool has_resolved_drv_goal = gcc_bug_workaround.has_value();
+
+    if (!gcc_bug_workaround) {
+        gcc_bug_workaround = {yield(), tryToBuild()};
+    }
+
+    if (!has_resolved_drv_goal) {
+        /* Second, the input sources. */
+        worker.store.computeFSClosure(drv->inputSrcs, inputPaths);
 
-    debug("added input paths %s", worker.store.showPaths(inputPaths));
+        debug("added input paths %s", worker.store.showPaths(inputPaths));
 
-    /* What type of derivation are we building? */
-    derivationType = drv->type();
+        /* What type of derivation are we building? */
+        derivationType = drv->type();
+    }
 
     /* Okay, try to build.  Note that here we don't wait for a build
        slot to become available, since we don't need one if there is a
        build hook. */
-    co_await yield();
-    co_return tryToBuild();
+    co_await std::move(gcc_bug_workaround->first);
+    co_return std::move(gcc_bug_workaround->second);
 }
 
 void DerivationGoal::started()