perf(libstore/derivation-builder): Futher simplify / maybe optimize

We can precompute the exact information we need for topo sorting and
store it in `PerhapsNeedToRegister`. Depending on how `topoSort` works,
this is easy a performance improvement or just completely harmless.

Co-Authored-By: Bernardo Meurer Costa <[email protected]>

Author: Ericson2314

src/libstore/unix/build/derivation-builder.cc

@@ -1396,6 +1396,11 @@ SingleDrvOutputs DerivationBuilderImpl::registerOutputs()
     struct PerhapsNeedToRegister
     {
         StorePathSet refs;
+        /**
+         * References to other outputs. Built by looking up in
+         * `scratchOutputsInverse`.
+         */
+        StringSet otherOutputs;
     };
 
     /* inverse map of scratchOutputs for efficient lookup */
@@ -1471,34 +1476,41 @@ SingleDrvOutputs DerivationBuilderImpl::registerOutputs()
             references = scanForReferences(blank, actualPath, referenceablePaths);
         }
 
-        outputReferencesIfUnregistered.insert_or_assign(outputName, PerhapsNeedToRegister{.refs = references});
+        StringSet referencedOutputs;
+        for (auto & r : references)
+            if (auto * o = get(scratchOutputsInverse, r))
+                referencedOutputs.insert(*o);
+
+        outputReferencesIfUnregistered.insert_or_assign(
+            outputName,
+            PerhapsNeedToRegister{
+                .refs = references,
+                .otherOutputs = referencedOutputs,
+            });
         outputStats.insert_or_assign(outputName, std::move(st));
     }
 
-    auto topoSortResult = topoSort(outputsToSort, {[&](const std::string & name) {
-                                       auto orifu = get(outputReferencesIfUnregistered, name);
-                                       if (!orifu)
-                                           throw BuildError(
-                                               BuildResult::Failure::OutputRejected,
-                                               "no output reference for '%s' in build of '%s'",
-                                               name,
-                                               store.printStorePath(drvPath));
-                                       return std::visit(
-                                           overloaded{
-                                               /* Since we'll use the already installed versions of these, we
-                                                  can treat them as leaves and ignore any references they
-                                                  have. */
-                                               [&](const AlreadyRegistered &) { return StringSet{}; },
-                                               [&](const PerhapsNeedToRegister & refs) {
-                                                   StringSet referencedOutputs;
-                                                   for (auto & r : refs.refs)
-                                                       if (auto * o = get(scratchOutputsInverse, r))
-                                                           referencedOutputs.insert(*o);
-                                                   return referencedOutputs;
-                                               },
-                                           },
-                                           *orifu);
-                                   }});
+    StringSet emptySet;
+
+    auto topoSortResult =
+        topoSort(outputsToSort, {[&](const std::string & name) {
+                     auto orifu = get(outputReferencesIfUnregistered, name);
+                     if (!orifu)
+                         throw BuildError(
+                             BuildResult::Failure::OutputRejected,
+                             "no output reference for '%s' in build of '%s'",
+                             name,
+                             store.printStorePath(drvPath));
+                     return std::visit(
+                         overloaded{
+                             /* Since we'll use the already installed versions of these, we
+                                can treat them as leaves and ignore any references they
+                                have. */
+                             [&](const AlreadyRegistered &) -> const StringSet & { return emptySet; },
+                             [&](const PerhapsNeedToRegister & refs) -> const StringSet & { return refs.otherOutputs; },
+                         },
+                         *orifu);
+                 }});
 
     auto sortedOutputNames = std::visit(
         overloaded{