Rename Buildable

35 files changed, 165 insertions, 162 deletions

diff --git a/src/libcmd/command.cc b/src/libcmd/command.cc
index d29954f67..dc1fbc43f 100644
--- a/src/libcmd/command.cc
+++ b/src/libcmd/command.cc
@@ -162,7 +162,7 @@ void MixProfile::updateProfile(const StorePath & storePath)
             profile2, storePath));
 }
 
-void MixProfile::updateProfile(const Buildables & buildables)
+void MixProfile::updateProfile(const DerivedPathsWithHints & buildables)
 {
     if (!profile) return;
 
@@ -170,10 +170,10 @@ void MixProfile::updateProfile(const Buildables & buildables)
 
     for (auto & buildable : buildables) {
         std::visit(overloaded {
-            [&](BuildableOpaque bo) {
+            [&](DerivedPathOpaque bo) {
                 result.push_back(bo.path);
             },
-            [&](BuildableFromDrv bfd) {
+            [&](DerivedPathWithHintsBuilt bfd) {
                 for (auto & output : bfd.outputs) {
                     /* Output path should be known because we just tried to
                        build it. */
diff --git a/src/libcmd/command.hh b/src/libcmd/command.hh
index e66c697eb..9e18c6e51 100644
--- a/src/libcmd/command.hh
+++ b/src/libcmd/command.hh
@@ -216,7 +216,7 @@ static RegisterCommand registerCommand2(std::vector<std::string> && name)
     return RegisterCommand(std::move(name), [](){ return make_ref<T>(); });
 }
 
-Buildables build(ref<Store> store, Realise mode,
+DerivedPathsWithHints build(ref<Store> store, Realise mode,
     std::vector<std::shared_ptr<Installable>> installables, BuildMode bMode = bmNormal);
 
 std::set<StorePath> toStorePaths(ref<Store> store,
@@ -252,7 +252,7 @@ struct MixProfile : virtual StoreCommand
 
     /* If 'profile' is set, make it point at the store path produced
        by 'buildables'. */
-    void updateProfile(const Buildables & buildables);
+    void updateProfile(const DerivedPathsWithHints & buildables);
 };
 
 struct MixDefaultProfile : MixProfile
diff --git a/src/libcmd/installables.cc b/src/libcmd/installables.cc
index b68c5f6a7..f091ac186 100644
--- a/src/libcmd/installables.cc
+++ b/src/libcmd/installables.cc
@@ -285,9 +285,9 @@ void completeFlakeRef(ref<Store> store, std::string_view prefix)
     }
 }
 
-Buildable Installable::toBuildable()
+DerivedPathWithHints Installable::toDerivedPathWithHints()
 {
-    auto buildables = toBuildables();
+    auto buildables = toDerivedPathsWithHints();
     if (buildables.size() != 1)
         throw Error("installable '%s' evaluates to %d derivations, where only one is expected", what(), buildables.size());
     return std::move(buildables[0]);
@@ -321,7 +321,7 @@ struct InstallableStorePath : Installable
 
     std::string what() override { return store->printStorePath(storePath); }
 
-    Buildables toBuildables() override
+    DerivedPathsWithHints toDerivedPathsWithHints() override
     {
         if (storePath.isDerivation()) {
             std::map<std::string, std::optional<StorePath>> outputs;
@@ -329,14 +329,14 @@ struct InstallableStorePath : Installable
             for (auto & [name, output] : drv.outputsAndOptPaths(*store))
                 outputs.emplace(name, output.second);
             return {
-                BuildableFromDrv {
+                DerivedPathWithHintsBuilt {
                     .drvPath = storePath,
                     .outputs = std::move(outputs)
                 }
             };
         } else {
             return {
-                BuildableOpaque {
+                DerivedPathOpaque {
                     .path = storePath,
                 }
             };
@@ -349,9 +349,9 @@ struct InstallableStorePath : Installable
     }
 };
 
-Buildables InstallableValue::toBuildables()
+DerivedPathsWithHints InstallableValue::toDerivedPathsWithHints()
 {
-    Buildables res;
+    DerivedPathsWithHints res;
 
     std::map<StorePath, std::map<std::string, std::optional<StorePath>>> drvsToOutputs;
 
@@ -364,7 +364,7 @@ Buildables InstallableValue::toBuildables()
     }
 
     for (auto & i : drvsToOutputs)
-        res.push_back(BuildableFromDrv { i.first, i.second });
+        res.push_back(DerivedPathWithHintsBuilt { i.first, i.second });
 
     return res;
 }
@@ -671,28 +671,28 @@ std::shared_ptr<Installable> SourceExprCommand::parseInstallable(
     return installables.front();
 }
 
-Buildables build(ref<Store> store, Realise mode,
+DerivedPathsWithHints build(ref<Store> store, Realise mode,
     std::vector<std::shared_ptr<Installable>> installables, BuildMode bMode)
 {
     if (mode == Realise::Nothing)
         settings.readOnlyMode = true;
 
-    Buildables buildables;
+    DerivedPathsWithHints buildables;
 
-    std::vector<BuildableReq> pathsToBuild;
+    std::vector<DerivedPath> pathsToBuild;
 
     for (auto & i : installables) {
-        for (auto & b : i->toBuildables()) {
+        for (auto & b : i->toDerivedPathsWithHints()) {
             std::visit(overloaded {
-                [&](BuildableOpaque bo) {
+                [&](DerivedPathOpaque bo) {
                     pathsToBuild.push_back(bo);
                 },
-                [&](BuildableFromDrv bfd) {
+                [&](DerivedPathWithHintsBuilt bfd) {
                     StringSet outputNames;
                     for (auto & output : bfd.outputs)
                         outputNames.insert(output.first);
                     pathsToBuild.push_back(
-                        BuildableReqFromDrv{bfd.drvPath, outputNames});
+                        DerivedPath::Built{bfd.drvPath, outputNames});
                 },
             }, b);
             buildables.push_back(std::move(b));
@@ -717,10 +717,10 @@ std::set<RealisedPath> toRealisedPaths(
     if (operateOn == OperateOn::Output) {
         for (auto & b : build(store, mode, installables))
             std::visit(overloaded {
-                [&](BuildableOpaque bo) {
+                [&](DerivedPathOpaque bo) {
                     res.insert(bo.path);
                 },
-                [&](BuildableFromDrv bfd) {
+                [&](DerivedPathWithHintsBuilt bfd) {
                     auto drv = store->readDerivation(bfd.drvPath);
                     auto outputHashes = staticOutputHashes(*store, drv);
                     for (auto & output : bfd.outputs) {
@@ -751,8 +751,8 @@ std::set<RealisedPath> toRealisedPaths(
             settings.readOnlyMode = true;
 
         for (auto & i : installables)
-            for (auto & b : i->toBuildables())
-                if (auto bfd = std::get_if<BuildableFromDrv>(&b))
+            for (auto & b : i->toDerivedPathsWithHints())
+                if (auto bfd = std::get_if<DerivedPathWithHintsBuilt>(&b))
                     res.insert(bfd->drvPath);
     }
 
@@ -787,9 +787,9 @@ StorePathSet toDerivations(ref<Store> store,
     StorePathSet drvPaths;
 
     for (auto & i : installables)
-        for (auto & b : i->toBuildables())
+        for (auto & b : i->toDerivedPathsWithHints())
             std::visit(overloaded {
-                [&](BuildableOpaque bo) {
+                [&](DerivedPathOpaque bo) {
                     if (!useDeriver)
                         throw Error("argument '%s' did not evaluate to a derivation", i->what());
                     auto derivers = store->queryValidDerivers(bo.path);
@@ -798,7 +798,7 @@ StorePathSet toDerivations(ref<Store> store,
                     // FIXME: use all derivers?
                     drvPaths.insert(*derivers.begin());
                 },
-                [&](BuildableFromDrv bfd) {
+                [&](DerivedPathWithHintsBuilt bfd) {
                     drvPaths.insert(bfd.drvPath);
                 },
             }, b);
diff --git a/src/libcmd/installables.hh b/src/libcmd/installables.hh
index e5c6fe208..0bc932b52 100644
--- a/src/libcmd/installables.hh
+++ b/src/libcmd/installables.hh
@@ -29,9 +29,9 @@ struct Installable
 
     virtual std::string what() = 0;
 
-    virtual Buildables toBuildables() = 0;
+    virtual DerivedPathsWithHints toDerivedPathsWithHints() = 0;
 
-    Buildable toBuildable();
+    DerivedPathWithHints toDerivedPathWithHints();
 
     App toApp(EvalState & state);
 
@@ -74,7 +74,7 @@ struct InstallableValue : Installable
 
     virtual std::vector<DerivationInfo> toDerivations() = 0;
 
-    Buildables toBuildables() override;
+    DerivedPathsWithHints toDerivedPathsWithHints() override;
 };
 
 struct InstallableFlake : InstallableValue
diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
index 24bc34b74..428adf4c2 100644
--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -35,7 +35,7 @@ InvalidPathError::InvalidPathError(const Path & path) :
 
 void EvalState::realiseContext(const PathSet & context)
 {
-    std::vector<BuildableReqFromDrv> drvs;
+    std::vector<DerivedPath::Built> drvs;
 
     for (auto & i : context) {
         auto [ctxS, outputName] = decodeContext(i);
@@ -56,8 +56,8 @@ void EvalState::realiseContext(const PathSet & context)
     /* For performance, prefetch all substitute info. */
     StorePathSet willBuild, willSubstitute, unknown;
     uint64_t downloadSize, narSize;
-    std::vector<BuildableReq> buildReqs;
-    for (auto & d : drvs) buildReqs.emplace_back(BuildableReq { d });
+    std::vector<DerivedPath> buildReqs;
+    for (auto & d : drvs) buildReqs.emplace_back(DerivedPath { d });
     store->queryMissing(buildReqs, willBuild, willSubstitute, unknown, downloadSize, narSize);
 
     store->buildPaths(buildReqs);
diff --git a/src/libmain/shared.cc b/src/libmain/shared.cc
index 20027e099..09af57871 100644
--- a/src/libmain/shared.cc
+++ b/src/libmain/shared.cc
@@ -36,7 +36,7 @@ void printGCWarning()
 }
 
 
-void printMissing(ref<Store> store, const std::vector<BuildableReq> & paths, Verbosity lvl)
+void printMissing(ref<Store> store, const std::vector<DerivedPath> & paths, Verbosity lvl)
 {
     uint64_t downloadSize, narSize;
     StorePathSet willBuild, willSubstitute, unknown;
diff --git a/src/libmain/shared.hh b/src/libmain/shared.hh
index 18e0fb57d..9cb9e6da2 100644
--- a/src/libmain/shared.hh
+++ b/src/libmain/shared.hh
@@ -43,7 +43,7 @@ struct StorePathWithOutputs;
 
 void printMissing(
     ref<Store> store,
-    const std::vector<BuildableReq> & paths,
+    const std::vector<DerivedPath> & paths,
     Verbosity lvl = lvlInfo);
 
 void printMissing(ref<Store> store, const StorePathSet & willBuild,
diff --git a/src/libstore/build/derivation-goal.cc b/src/libstore/build/derivation-goal.cc
index 8396abbcd..3ce538f77 100644
--- a/src/libstore/build/derivation-goal.cc
+++ b/src/libstore/build/derivation-goal.cc
@@ -73,7 +73,7 @@ DerivationGoal::DerivationGoal(const StorePath & drvPath,
     state = &DerivationGoal::getDerivation;
     name = fmt(
         "building of '%s' from .drv file",
-        BuildableReqFromDrv { drvPath, wantedOutputs }.to_string(worker.store));
+        DerivedPath::Built { drvPath, wantedOutputs }.to_string(worker.store));
     trace("created");
 
     mcExpectedBuilds = std::make_unique<MaintainCount<uint64_t>>(worker.expectedBuilds);
@@ -94,7 +94,7 @@ DerivationGoal::DerivationGoal(const StorePath & drvPath, const BasicDerivation
     state = &DerivationGoal::haveDerivation;
     name = fmt(
         "building of '%s' from in-memory derivation",
-        BuildableReqFromDrv { drvPath, drv.outputNames() }.to_string(worker.store));
+        DerivedPath::Built { drvPath, drv.outputNames() }.to_string(worker.store));
     trace("created");
 
     mcExpectedBuilds = std::make_unique<MaintainCount<uint64_t>>(worker.expectedBuilds);
diff --git a/src/libstore/build/entry-points.cc b/src/libstore/build/entry-points.cc
index fc6294545..732d4785d 100644
--- a/src/libstore/build/entry-points.cc
+++ b/src/libstore/build/entry-points.cc
@@ -6,17 +6,17 @@
 
 namespace nix {
 
-void Store::buildPaths(const std::vector<BuildableReq> & reqs, BuildMode buildMode)
+void Store::buildPaths(const std::vector<DerivedPath> & reqs, BuildMode buildMode)
 {
     Worker worker(*this);
 
     Goals goals;
     for (auto & br : reqs) {
         std::visit(overloaded {
-            [&](BuildableReqFromDrv bfd) {
+            [&](DerivedPath::Built bfd) {
                 goals.insert(worker.makeDerivationGoal(bfd.drvPath, bfd.outputs, buildMode));
             },
-            [&](BuildableOpaque bo) {
+            [&](DerivedPath::Opaque bo) {
                 goals.insert(worker.makePathSubstitutionGoal(bo.path, buildMode == bmRepair ? Repair : NoRepair));
             },
         }, br.raw());
diff --git a/src/libstore/build/local-derivation-goal.cc b/src/libstore/build/local-derivation-goal.cc
index 6cc384719..7c1402918 100644
--- a/src/libstore/build/local-derivation-goal.cc
+++ b/src/libstore/build/local-derivation-goal.cc
@@ -1191,20 +1191,20 @@ void LocalDerivationGoal::writeStructuredAttrs()
 }
 
 
-static StorePath pathPartOfReq(const BuildableReq & req)
+static StorePath pathPartOfReq(const DerivedPath & req)
 {
     return std::visit(overloaded {
-        [&](BuildableOpaque bo) {
+        [&](DerivedPath::Opaque bo) {
             return bo.path;
         },
-        [&](BuildableReqFromDrv bfd)  {
+        [&](DerivedPath::Built bfd)  {
             return bfd.drvPath;
         },
     }, req.raw());
 }
 
 
-bool LocalDerivationGoal::isAllowed(const BuildableReq & req)
+bool LocalDerivationGoal::isAllowed(const DerivedPath & req)
 {
     return this->isAllowed(pathPartOfReq(req));
 }
@@ -1332,7 +1332,7 @@ struct RestrictedStore : public virtual RestrictedStoreConfig, public virtual Lo
     // an allowed derivation
     { throw Error("queryRealisation"); }
 
-    void buildPaths(const std::vector<BuildableReq> & paths, BuildMode buildMode) override
+    void buildPaths(const std::vector<DerivedPath> & paths, BuildMode buildMode) override
     {
         if (buildMode != bmNormal) throw Error("unsupported build mode");
 
@@ -1346,7 +1346,7 @@ struct RestrictedStore : public virtual RestrictedStoreConfig, public virtual Lo
         next->buildPaths(paths, buildMode);
 
         for (auto & path : paths) {
-            auto p =  std::get_if<BuildableReqFromDrv>(&path);
+            auto p =  std::get_if<DerivedPath::Built>(&path);
             if (!p) continue;
             auto & bfd = *p;
             auto outputs = next->queryDerivationOutputMap(bfd.drvPath);
@@ -1380,7 +1380,7 @@ struct RestrictedStore : public virtual RestrictedStoreConfig, public virtual Lo
     void addSignatures(const StorePath & storePath, const StringSet & sigs) override
     { unsupported("addSignatures"); }
 
-    void queryMissing(const std::vector<BuildableReq> & targets,
+    void queryMissing(const std::vector<DerivedPath> & targets,
         StorePathSet & willBuild, StorePathSet & willSubstitute, StorePathSet & unknown,
         uint64_t & downloadSize, uint64_t & narSize) override
     {
@@ -1388,7 +1388,7 @@ struct RestrictedStore : public virtual RestrictedStoreConfig, public virtual Lo
            client about what paths will be built/substituted or are
            already present. Probably not a big deal. */
 
-        std::vector<BuildableReq> allowed;
+        std::vector<DerivedPath> allowed;
         for (auto & req : targets) {
             if (goal.isAllowed(req))
                 allowed.emplace_back(req);
diff --git a/src/libstore/build/local-derivation-goal.hh b/src/libstore/build/local-derivation-goal.hh
index edb93f84e..d30be2351 100644
--- a/src/libstore/build/local-derivation-goal.hh
+++ b/src/libstore/build/local-derivation-goal.hh
@@ -116,7 +116,7 @@ struct LocalDerivationGoal : public DerivationGoal
     {
         return inputPaths.count(path) || addedPaths.count(path);
     }
-    bool isAllowed(const BuildableReq & req);
+    bool isAllowed(const DerivedPath & req);
 
     friend struct RestrictedStore;
 
diff --git a/src/libstore/build/worker.cc b/src/libstore/build/worker.cc
index fef4cb0cb..6c04d3ed3 100644
--- a/src/libstore/build/worker.cc
+++ b/src/libstore/build/worker.cc
@@ -226,14 +226,14 @@ void Worker::waitForAWhile(GoalPtr goal)
 
 void Worker::run(const Goals & _topGoals)
 {
-    std::vector<nix::BuildableReq> topPaths;
+    std::vector<nix::DerivedPath> topPaths;
 
     for (auto & i : _topGoals) {
         topGoals.insert(i);
         if (auto goal = dynamic_cast<DerivationGoal *>(i.get())) {
-            topPaths.push_back(BuildableReqFromDrv{goal->drvPath, goal->wantedOutputs});
+            topPaths.push_back(DerivedPath::Built{goal->drvPath, goal->wantedOutputs});
         } else if (auto goal = dynamic_cast<PathSubstitutionGoal *>(i.get())) {
-            topPaths.push_back(BuildableOpaque{goal->storePath});
+            topPaths.push_back(DerivedPath::Opaque{goal->storePath});
         }
     }
 
diff --git a/src/libstore/buildable.cc b/src/libstore/buildable.cc
index 31fef2faa..a8c0c70b1 100644
--- a/src/libstore/buildable.cc
+++ b/src/libstore/buildable.cc
@@ -5,13 +5,13 @@
 
 namespace nix {
 
-nlohmann::json BuildableOpaque::toJSON(ref<Store> store) const {
+nlohmann::json DerivedPath::Opaque::toJSON(ref<Store> store) const {
     nlohmann::json res;
     res["path"] = store->printStorePath(path);
     return res;
 }
 
-nlohmann::json BuildableFromDrv::toJSON(ref<Store> store) const {
+nlohmann::json DerivedPathWithHintsBuilt::toJSON(ref<Store> store) const {
     nlohmann::json res;
     res["drvPath"] = store->printStorePath(drvPath);
     for (const auto& [output, path] : outputs) {
@@ -20,9 +20,9 @@ nlohmann::json BuildableFromDrv::toJSON(ref<Store> store) const {
     return res;
 }
 
-nlohmann::json buildablesToJSON(const Buildables & buildables, ref<Store> store) {
+nlohmann::json derivedPathsWithHintsToJSON(const DerivedPathsWithHints & buildables, ref<Store> store) {
     auto res = nlohmann::json::array();
-    for (const Buildable & buildable : buildables) {
+    for (const DerivedPathWithHints & buildable : buildables) {
         std::visit([&res, store](const auto & buildable) {
             res.push_back(buildable.toJSON(store));
         }, buildable);
@@ -31,17 +31,17 @@ nlohmann::json buildablesToJSON(const Buildables & buildables, ref<Store> store)
 }
 
 
-std::string BuildableOpaque::to_string(const Store & store) const {
+std::string DerivedPath::Opaque::to_string(const Store & store) const {
     return store.printStorePath(path);
 }
 
-std::string BuildableReqFromDrv::to_string(const Store & store) const {
+std::string DerivedPath::Built::to_string(const Store & store) const {
     return store.printStorePath(drvPath)
         + "!"
         + (outputs.empty() ? std::string { "*" } : concatStringsSep(",", outputs));
 }
 
-std::string BuildableReq::to_string(const Store & store) const
+std::string DerivedPath::to_string(const Store & store) const
 {
     return std::visit(
         [&](const auto & req) { return req.to_string(store); },
@@ -49,12 +49,12 @@ std::string BuildableReq::to_string(const Store & store) const
 }
 
 
-BuildableOpaque BuildableOpaque::parse(const Store & store, std::string_view s)
+DerivedPath::Opaque DerivedPath::Opaque::parse(const Store & store, std::string_view s)
 {
     return {store.parseStorePath(s)};
 }
 
-BuildableReqFromDrv BuildableReqFromDrv::parse(const Store & store, std::string_view s)
+DerivedPath::Built DerivedPath::Built::parse(const Store & store, std::string_view s)
 {
     size_t n = s.find("!");
     assert(n != s.npos);
@@ -66,12 +66,12 @@ BuildableReqFromDrv BuildableReqFromDrv::parse(const Store & store, std::string_
     return {drvPath, outputs};
 }
 
-BuildableReq BuildableReq::parse(const Store & store, std::string_view s)
+DerivedPath DerivedPath::parse(const Store & store, std::string_view s)
 {
     size_t n = s.find("!");
     return n == s.npos
-        ? (BuildableReq) BuildableOpaque::parse(store, s)
-        : (BuildableReq) BuildableReqFromDrv::parse(store, s);
+        ? (DerivedPath) DerivedPath::Opaque::parse(store, s)
+        : (DerivedPath) DerivedPath::Built::parse(store, s);
 }
 
 }
diff --git a/src/libstore/buildable.hh b/src/libstore/buildable.hh
index 8317f3995..0a0cf8105 100644
--- a/src/libstore/buildable.hh
+++ b/src/libstore/buildable.hh
@@ -12,54 +12,57 @@ namespace nix {
 
 class Store;
 
-struct BuildableOpaque {
+struct DerivedPathOpaque {
     StorePath path;
 
     nlohmann::json toJSON(ref<Store> store) const;
     std::string to_string(const Store & store) const;
-    static BuildableOpaque parse(const Store & store, std::string_view);
+    static DerivedPathOpaque parse(const Store & store, std::string_view);
 };
 
-struct BuildableReqFromDrv {
+struct DerivedPathBuilt {
     StorePath drvPath;
     std::set<std::string> outputs;
 
     std::string to_string(const Store & store) const;
-    static BuildableReqFromDrv parse(const Store & store, std::string_view);
+    static DerivedPathBuilt parse(const Store & store, std::string_view);
 };
 
-using _BuildableReqRaw = std::variant<
-    BuildableOpaque,
-    BuildableReqFromDrv
+using _DerivedPathRaw = std::variant<
+    DerivedPathOpaque,
+    DerivedPathBuilt
 >;
 
-struct BuildableReq : _BuildableReqRaw {
-    using Raw = _BuildableReqRaw;
+struct DerivedPath : _DerivedPathRaw {
+    using Raw = _DerivedPathRaw;
     using Raw::Raw;
 
+    using Opaque = DerivedPathOpaque;
+    using Built = DerivedPathBuilt;
+
     inline const Raw & raw() const {
         return static_cast<const Raw &>(*this);
     }
 
     std::string to_string(const Store & store) const;
-    static BuildableReq parse(const Store & store, std::string_view);
+    static DerivedPath parse(const Store & store, std::string_view);
 };
 
-struct BuildableFromDrv {
+struct DerivedPathWithHintsBuilt {
     StorePath drvPath;
     std::map<std::string, std::optional<StorePath>> outputs;
 
     nlohmann::json toJSON(ref<Store> store) const;
-    static BuildableFromDrv parse(const Store & store, std::string_view);
+    static DerivedPathWithHintsBuilt parse(const Store & store, std::string_view);
 };
 
-using Buildable = std::variant<
-    BuildableOpaque,
-    BuildableFromDrv
+using DerivedPathWithHints = std::variant<
+    DerivedPath::Opaque,
+    DerivedPathWithHintsBuilt
 >;
 
-typedef std::vector<Buildable> Buildables;
+typedef std::vector<DerivedPathWithHints> DerivedPathsWithHints;
 
-nlohmann::json buildablesToJSON(const Buildables & buildables, ref<Store> store);
+nlohmann::json derivedPathsWithHintsToJSON(const DerivedPathsWithHints & buildables, ref<Store> store);
 
 }
diff --git a/src/libstore/daemon.cc b/src/libstore/daemon.cc
index 6b527dcb2..affd60472 100644
--- a/src/libstore/daemon.cc
+++ b/src/libstore/daemon.cc
@@ -260,14 +260,14 @@ static void writeValidPathInfo(
     }
 }
 
-static std::vector<BuildableReq> readBuildableReqs(Store & store, unsigned int clientVersion, Source & from)
+static std::vector<DerivedPath> readDerivedPaths(Store & store, unsigned int clientVersion, Source & from)
 {
-    std::vector<BuildableReq> reqs;
+    std::vector<DerivedPath> reqs;
     if (GET_PROTOCOL_MINOR(clientVersion) >= 29) {
-        reqs = worker_proto::read(store, from, Phantom<std::vector<BuildableReq>> {});
+        reqs = worker_proto::read(store, from, Phantom<std::vector<DerivedPath>> {});
     } else {
         for (auto & s : readStrings<Strings>(from))
-            reqs.push_back(parsePathWithOutputs(store, s).toBuildableReq());
+            reqs.push_back(parsePathWithOutputs(store, s).toDerivedPath());
     }
     return reqs;
 }
@@ -506,7 +506,7 @@ static void performOp(TunnelLogger * logger, ref<Store> store,
     }
 
     case wopBuildPaths: {
-        auto drvs = readBuildableReqs(*store, clientVersion, from);
+        auto drvs = readDerivedPaths(*store, clientVersion, from);
         BuildMode mode = bmNormal;
         if (GET_PROTOCOL_MINOR(clientVersion) >= 15) {
             mode = (BuildMode) readInt(from);
@@ -870,7 +870,7 @@ static void performOp(TunnelLogger * logger, ref<Store> store,
     }
 
     case wopQueryMissing: {
-        auto targets = readBuildableReqs(*store, clientVersion, from);
+        auto targets = readDerivedPaths(*store, clientVersion, from);
         logger->startWork();
         StorePathSet willBuild, willSubstitute, unknown;
         uint64_t downloadSize, narSize;
diff --git a/src/libstore/legacy-ssh-store.cc b/src/libstore/legacy-ssh-store.cc
index 1cb977be6..edaf75136 100644
--- a/src/libstore/legacy-ssh-store.cc
+++ b/src/libstore/legacy-ssh-store.cc
@@ -267,14 +267,14 @@ public:
         return status;
     }
 
-    void buildPaths(const std::vector<BuildableReq> & drvPaths, BuildMode buildMode) override
+    void buildPaths(const std::vector<DerivedPath> & drvPaths, BuildMode buildMode) override
     {
         auto conn(connections->get());
 
         conn->to << cmdBuildPaths;
         Strings ss;
         for (auto & p : drvPaths) {
-            auto sOrDrvPath = StorePathWithOutputs::tryFromBuildableReq(p);
+            auto sOrDrvPath = StorePathWithOutputs::tryFromDerivedPath(p);
             std::visit(overloaded {
                 [&](StorePathWithOutputs s) {
                     ss.push_back(s.to_string(*this));
diff --git a/src/libstore/misc.cc b/src/libstore/misc.cc
index abfae1502..a99a2fc78 100644
--- a/src/libstore/misc.cc
+++ b/src/libstore/misc.cc
@@ -117,7 +117,7 @@ std::optional<ContentAddress> getDerivationCA(const BasicDerivation & drv)
     return std::nullopt;
 }
 
-void Store::queryMissing(const std::vector<BuildableReq> & targets,
+void Store::queryMissing(const std::vector<DerivedPath> & targets,
     StorePathSet & willBuild_, StorePathSet & willSubstitute_, StorePathSet & unknown_,
     uint64_t & downloadSize_, uint64_t & narSize_)
 {
@@ -145,7 +145,7 @@ void Store::queryMissing(const std::vector<BuildableReq> & targets,
 
     Sync<State> state_(State{{}, unknown_, willSubstitute_, willBuild_, downloadSize_, narSize_});
 
-    std::function<void(BuildableReq)> doPath;
+    std::function<void(DerivedPath)> doPath;
 
     auto mustBuildDrv = [&](const StorePath & drvPath, const Derivation & drv) {
         {
@@ -154,7 +154,7 @@ void Store::queryMissing(const std::vector<BuildableReq> & targets,
         }
 
         for (auto & i : drv.inputDrvs)
-            pool.enqueue(std::bind(doPath, BuildableReqFromDrv { i.first, i.second }));
+            pool.enqueue(std::bind(doPath, DerivedPath::Built { i.first, i.second }));
     };
 
     auto checkOutput = [&](
@@ -177,13 +177,13 @@ void Store::queryMissing(const std::vector<BuildableReq> & targets,
                 drvState->outPaths.insert(outPath);
                 if (!drvState->left) {
                     for (auto & path : drvState->outPaths)
-                        pool.enqueue(std::bind(doPath, BuildableOpaque { path } ));
+                        pool.enqueue(std::bind(doPath, DerivedPath::Opaque { path } ));
                 }
             }
         }
     };
 
-    doPath = [&](const BuildableReq & req) {
+    doPath = [&](const DerivedPath & req) {
 
         {
             auto state(state_.lock());
@@ -191,7 +191,7 @@ void Store::queryMissing(const std::vector<BuildableReq> & targets,
         }
 
         std::visit(overloaded {
-          [&](BuildableReqFromDrv bfd) {
+          [&](DerivedPath::Built bfd) {
             if (!isValidPath(bfd.drvPath)) {
                 // FIXME: we could try to substitute the derivation.
                 auto state(state_.lock());
@@ -224,7 +224,7 @@ void Store::queryMissing(const std::vector<BuildableReq> & targets,
                 mustBuildDrv(bfd.drvPath, *drv);
 
           },
-          [&](BuildableOpaque bo) {
+          [&](DerivedPath::Opaque bo) {
 
             if (isValidPath(bo.path)) return;
 
@@ -248,7 +248,7 @@ void Store::queryMissing(const std::vector<BuildableReq> & targets,
             }
 
             for (auto & ref : info->second.references)
-                pool.enqueue(std::bind(doPath, BuildableOpaque { ref }));
+                pool.enqueue(std::bind(doPath, DerivedPath::Opaque { ref }));
           },
         }, req.raw());
     };
diff --git a/src/libstore/path-with-outputs.cc b/src/libstore/path-with-outputs.cc
index 2898b8d4f..865d64cf2 100644
--- a/src/libstore/path-with-outputs.cc
+++ b/src/libstore/path-with-outputs.cc
@@ -11,34 +11,34 @@ std::string StorePathWithOutputs::to_string(const Store & store) const
 }
 
 
-BuildableReq StorePathWithOutputs::toBuildableReq() const
+DerivedPath StorePathWithOutputs::toDerivedPath() const
 {
     if (!outputs.empty() || path.isDerivation())
-        return BuildableReqFromDrv { path, outputs };
+        return DerivedPath::Built { path, outputs };
     else
-        return BuildableOpaque { path };
+        return DerivedPath::Opaque { path };
 }
 
 
-std::vector<BuildableReq> toBuildableReqs(const std::vector<StorePathWithOutputs> ss)
+std::vector<DerivedPath> toDerivedPaths(const std::vector<StorePathWithOutputs> ss)
 {
-	std::vector<BuildableReq> reqs;
-	for (auto & s : ss) reqs.push_back(s.toBuildableReq());
+	std::vector<DerivedPath> reqs;
+	for (auto & s : ss) reqs.push_back(s.toDerivedPath());
 	return reqs;
 }
 
 
-std::variant<StorePathWithOutputs, StorePath> StorePathWithOutputs::tryFromBuildableReq(const BuildableReq & p)
+std::variant<StorePathWithOutputs, StorePath> StorePathWithOutputs::tryFromDerivedPath(const DerivedPath & p)
 {
     return std::visit(overloaded {
-        [&](BuildableOpaque bo) -> std::variant<StorePathWithOutputs, StorePath> {
+        [&](DerivedPath::Opaque bo) -> std::variant<StorePathWithOutputs, StorePath> {
             if (bo.path.isDerivation()) {
                 // drv path gets interpreted as "build", not "get drv file itself"
                 return bo.path;
             }
             return StorePathWithOutputs { bo.path };
         },
-        [&](BuildableReqFromDrv bfd) -> std::variant<StorePathWithOutputs, StorePath> {
+        [&](DerivedPath::Built bfd) -> std::variant<StorePathWithOutputs, StorePath> {
             return StorePathWithOutputs { bfd.drvPath, bfd.outputs };
         },
     }, p.raw());
diff --git a/src/libstore/path-with-outputs.hh b/src/libstore/path-with-outputs.hh
index 870cac08e..749348398 100644
--- a/src/libstore/path-with-outputs.hh
+++ b/src/libstore/path-with-outputs.hh
@@ -14,12 +14,12 @@ struct StorePathWithOutputs
 
     std::string to_string(const Store & store) const;
 
-    BuildableReq toBuildableReq() const;
+    DerivedPath toDerivedPath() const;
 
-    static std::variant<StorePathWithOutputs, StorePath> tryFromBuildableReq(const BuildableReq &);
+    static std::variant<StorePathWithOutputs, StorePath> tryFromDerivedPath(const DerivedPath &);
 };
 
-std::vector<BuildableReq> toBuildableReqs(const std::vector<StorePathWithOutputs>);
+std::vector<DerivedPath> toDerivedPaths(const std::vector<StorePathWithOutputs>);
 
 std::pair<std::string_view, StringSet> parsePathWithOutputs(std::string_view s);
 
diff --git a/src/libstore/remote-store.cc b/src/libstore/remote-store.cc
index cb6402213..761b4a087 100644
--- a/src/libstore/remote-store.cc
+++ b/src/libstore/remote-store.cc
@@ -52,13 +52,13 @@ void write(const Store & store, Sink & out, const ContentAddress & ca)
 }
 
 
-BuildableReq read(const Store & store, Source & from, Phantom<BuildableReq> _)
+DerivedPath read(const Store & store, Source & from, Phantom<DerivedPath> _)
 {
     auto s = readString(from);
-    return BuildableReq::parse(store, s);
+    return DerivedPath::parse(store, s);
 }
 
-void write(const Store & store, Sink & out, const BuildableReq & req)
+void write(const Store & store, Sink & out, const DerivedPath & req)
 {
     out << req.to_string(store);
 }
@@ -670,14 +670,14 @@ std::optional<const Realisation> RemoteStore::queryRealisation(const DrvOutput &
     return {Realisation{.id = id, .outPath = *outPaths.begin()}};
 }
 
-static void writeBuildableReqs(RemoteStore & store, ConnectionHandle & conn, const std::vector<BuildableReq> & reqs)
+static void writeDerivedPaths(RemoteStore & store, ConnectionHandle & conn, const std::vector<DerivedPath> & reqs)
 {
     if (GET_PROTOCOL_MINOR(conn->daemonVersion) >= 29) {
         worker_proto::write(store, conn->to, reqs);
     } else {
         Strings ss;
         for (auto & p : reqs) {
-            auto sOrDrvPath = StorePathWithOutputs::tryFromBuildableReq(p);
+            auto sOrDrvPath = StorePathWithOutputs::tryFromDerivedPath(p);
             std::visit(overloaded {
                 [&](StorePathWithOutputs s) {
                     ss.push_back(s.to_string(store));
@@ -694,12 +694,12 @@ static void writeBuildableReqs(RemoteStore & store, ConnectionHandle & conn, con
     }
 }
 
-void RemoteStore::buildPaths(const std::vector<BuildableReq> & drvPaths, BuildMode buildMode)
+void RemoteStore::buildPaths(const std::vector<DerivedPath> & drvPaths, BuildMode buildMode)
 {
     auto conn(getConnection());
     conn->to << wopBuildPaths;
     assert(GET_PROTOCOL_MINOR(conn->daemonVersion) >= 13);
-    writeBuildableReqs(*this, conn, drvPaths);
+    writeDerivedPaths(*this, conn, drvPaths);
     if (GET_PROTOCOL_MINOR(conn->daemonVersion) >= 15)
         conn->to << buildMode;
     else
@@ -838,7 +838,7 @@ void RemoteStore::addSignatures(const StorePath & storePath, const StringSet & s
 }
 
 
-void RemoteStore::queryMissing(const std::vector<BuildableReq> & targets,
+void RemoteStore::queryMissing(const std::vector<DerivedPath> & targets,
     StorePathSet & willBuild, StorePathSet & willSubstitute, StorePathSet & unknown,
     uint64_t & downloadSize, uint64_t & narSize)
 {
@@ -849,7 +849,7 @@ void RemoteStore::queryMissing(const std::vector<BuildableReq> & targets,
             // to prevent a deadlock.
             goto fallback;
         conn->to << wopQueryMissing;
-        writeBuildableReqs(*this, conn, targets);
+        writeDerivedPaths(*this, conn, targets);
         conn.processStderr();
         willBuild = worker_proto::read(*this, conn->from, Phantom<StorePathSet> {});
         willSubstitute = worker_proto::read(*this, conn->from, Phantom<StorePathSet> {});
diff --git a/src/libstore/remote-store.hh b/src/libstore/remote-store.hh
index 20d366038..6cf76a46d 100644
--- a/src/libstore/remote-store.hh
+++ b/src/libstore/remote-store.hh
@@ -85,7 +85,7 @@ public:
 
     std::optional<const Realisation> queryRealisation(const DrvOutput &) override;
 
-    void buildPaths(const std::vector<BuildableReq> & paths, BuildMode buildMode) override;
+    void buildPaths(const std::vector<DerivedPath> & paths, BuildMode buildMode) override;
 
     BuildResult buildDerivation(const StorePath & drvPath, const BasicDerivation & drv,
         BuildMode buildMode) override;
@@ -108,7 +108,7 @@ public:
 
     void addSignatures(const StorePath & storePath, const StringSet & sigs) override;
 
-    void queryMissing(const std::vector<BuildableReq> & targets,
+    void queryMissing(const std::vector<DerivedPath> & targets,
         StorePathSet & willBuild, StorePathSet & willSubstitute, StorePathSet & unknown,
         uint64_t & downloadSize, uint64_t & narSize) override;
 
diff --git a/src/libstore/store-api.cc b/src/libstore/store-api.cc
index 8b60bdc62..93fcb068f 100644
--- a/src/libstore/store-api.cc
+++ b/src/libstore/store-api.cc
@@ -529,10 +529,10 @@ void Store::queryPathInfo(const StorePath & storePath,
 
 void Store::substitutePaths(const StorePathSet & paths)
 {
-    std::vector<BuildableReq> paths2;
+    std::vector<DerivedPath> paths2;
     for (auto & path : paths)
         if (!path.isDerivation())
-            paths2.push_back(BuildableOpaque{path});
+            paths2.push_back(DerivedPath::Opaque{path});
     uint64_t downloadSize, narSize;
     StorePathSet willBuild, willSubstitute, unknown;
     queryMissing(paths2,
@@ -540,8 +540,8 @@ void Store::substitutePaths(const StorePathSet & paths)
 
     if (!willSubstitute.empty())
         try {
-            std::vector<BuildableReq> subs;
-            for (auto & p : willSubstitute) subs.push_back(BuildableOpaque{p});
+            std::vector<DerivedPath> subs;
+            for (auto & p : willSubstitute) subs.push_back(DerivedPath::Opaque{p});
             buildPaths(subs);
         } catch (Error & e) {
             logWarning(e.info());
diff --git a/src/libstore/store-api.hh b/src/libstore/store-api.hh
index 59d0983df..483f3c5fa 100644
--- a/src/libstore/store-api.hh
+++ b/src/libstore/store-api.hh
@@ -494,7 +494,7 @@ public:
        recursively building any sub-derivations. For inputs that are
        not derivations, substitute them. */
     virtual void buildPaths(
-        const std::vector<BuildableReq> & paths,
+        const std::vector<DerivedPath> & paths,
         BuildMode buildMode = bmNormal);
 
     /* Build a single non-materialized derivation (i.e. not from an
@@ -656,7 +656,7 @@ public:
     /* Given a set of paths that are to be built, return the set of
        derivations that will be built, and the set of output paths
        that will be substituted. */
-    virtual void queryMissing(const std::vector<BuildableReq> & targets,
+    virtual void queryMissing(const std::vector<DerivedPath> & targets,
         StorePathSet & willBuild, StorePathSet & willSubstitute, StorePathSet & unknown,
         uint64_t & downloadSize, uint64_t & narSize);
 
diff --git a/src/libstore/worker-protocol.hh b/src/libstore/worker-protocol.hh
index 0255726ac..001ed25e3 100644
--- a/src/libstore/worker-protocol.hh
+++ b/src/libstore/worker-protocol.hh
@@ -86,7 +86,7 @@ namespace worker_proto {
 MAKE_WORKER_PROTO(, std::string);
 MAKE_WORKER_PROTO(, StorePath);
 MAKE_WORKER_PROTO(, ContentAddress);
-MAKE_WORKER_PROTO(, BuildableReq);
+MAKE_WORKER_PROTO(, DerivedPath);
 MAKE_WORKER_PROTO(, Realisation);
 MAKE_WORKER_PROTO(, DrvOutput);
 
diff --git a/src/nix-build/nix-build.cc b/src/nix-build/nix-build.cc
index 6f8a61261..d46bc1f2b 100755
--- a/src/nix-build/nix-build.cc
+++ b/src/nix-build/nix-build.cc
@@ -323,7 +323,7 @@ static void main_nix_build(int argc, char * * argv)
     state->printStats();
 
     auto buildPaths = [&](const std::vector<StorePathWithOutputs> & paths0) {
-        auto paths = toBuildableReqs(paths0);
+        auto paths = toDerivedPaths(paths0);
         /* Note: we do this even when !printMissing to efficiently
            fetch binary cache data. */
         uint64_t downloadSize, narSize;
diff --git a/src/nix-env/nix-env.cc b/src/nix-env/nix-env.cc
index af1c69b87..e04954d45 100644
--- a/src/nix-env/nix-env.cc
+++ b/src/nix-env/nix-env.cc
@@ -419,13 +419,13 @@ static void queryInstSources(EvalState & state,
 
 static void printMissing(EvalState & state, DrvInfos & elems)
 {
-    std::vector<BuildableReq> targets;
+    std::vector<DerivedPath> targets;
     for (auto & i : elems) {
         Path drvPath = i.queryDrvPath();
         if (drvPath != "")
-            targets.push_back(BuildableReqFromDrv{state.store->parseStorePath(drvPath)});
+            targets.push_back(DerivedPath::Built{state.store->parseStorePath(drvPath)});
         else
-            targets.push_back(BuildableOpaque{state.store->parseStorePath(i.queryOutPath())});
+            targets.push_back(DerivedPath::Opaque{state.store->parseStorePath(i.queryOutPath())});
     }
 
     printMissing(state.store, targets);
@@ -694,12 +694,12 @@ static void opSet(Globals & globals, Strings opFlags, Strings opArgs)
     if (globals.forceName != "")
         drv.setName(globals.forceName);
 
-    std::vector<BuildableReq> paths {
+    std::vector<DerivedPath> paths {
         (drv.queryDrvPath() != "")
-        ? (BuildableReq) (BuildableReqFromDrv {
+        ? (DerivedPath) (DerivedPath::Built {
                 globals.state->store->parseStorePath(drv.queryDrvPath())
             })
-        : (BuildableReq) (BuildableOpaque {
+        : (DerivedPath) (DerivedPath::Opaque {
                 globals.state->store->parseStorePath(drv.queryOutPath())
             }),
     };
diff --git a/src/nix-env/user-env.cc b/src/nix-env/user-env.cc
index 0ccf960fb..5ceb2ae67 100644
--- a/src/nix-env/user-env.cc
+++ b/src/nix-env/user-env.cc
@@ -43,7 +43,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
 
     debug(format("building user environment dependencies"));
     state.store->buildPaths(
-        toBuildableReqs(drvsToBuild),
+        toDerivedPaths(drvsToBuild),
         state.repair ? bmRepair : bmNormal);
 
     /* Construct the whole top level derivation. */
@@ -140,7 +140,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
     std::vector<StorePathWithOutputs> topLevelDrvs;
     topLevelDrvs.push_back({topLevelDrv});
     state.store->buildPaths(
-        toBuildableReqs(topLevelDrvs),
+        toDerivedPaths(topLevelDrvs),
         state.repair ? bmRepair : bmNormal);
 
     /* Switch the current user environment to the output path. */
diff --git a/src/nix-store/nix-store.cc b/src/nix-store/nix-store.cc
index 21c1e547b..b327793e7 100644
--- a/src/nix-store/nix-store.cc
+++ b/src/nix-store/nix-store.cc
@@ -63,7 +63,7 @@ static PathSet realisePath(StorePathWithOutputs path, bool build = true)
     auto store2 = std::dynamic_pointer_cast<LocalFSStore>(store);
 
     if (path.path.isDerivation()) {
-        if (build) store->buildPaths({path.toBuildableReq()});
+        if (build) store->buildPaths({path.toDerivedPath()});
         auto outputPaths = store->queryDerivationOutputMap(path.path);
         Derivation drv = store->derivationFromPath(path.path);
         rootNr++;
@@ -134,7 +134,7 @@ static void opRealise(Strings opFlags, Strings opArgs)
     uint64_t downloadSize, narSize;
     StorePathSet willBuild, willSubstitute, unknown;
     store->queryMissing(
-        toBuildableReqs(paths),
+        toDerivedPaths(paths),
         willBuild, willSubstitute, unknown, downloadSize, narSize);
 
     if (ignoreUnknown) {
@@ -151,7 +151,7 @@ static void opRealise(Strings opFlags, Strings opArgs)
     if (dryRun) return;
 
     /* Build all paths at the same time to exploit parallelism. */
-    store->buildPaths(toBuildableReqs(paths), buildMode);
+    store->buildPaths(toDerivedPaths(paths), buildMode);
 
     if (!ignoreUnknown)
         for (auto & i : paths) {
@@ -882,7 +882,7 @@ static void opServe(Strings opFlags, Strings opArgs)
 
                 try {
                     MonitorFdHup monitor(in.fd);
-                    store->buildPaths(toBuildableReqs(paths));
+                    store->buildPaths(toDerivedPaths(paths));
                     out << 0;
                 } catch (Error & e) {
                     assert(e.status);
diff --git a/src/nix/build.cc b/src/nix/build.cc
index 724ce9d79..0529ed382 100644
--- a/src/nix/build.cc
+++ b/src/nix/build.cc
@@ -61,12 +61,12 @@ struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
                 for (const auto & [_i, buildable] : enumerate(buildables)) {
                     auto i = _i;
                     std::visit(overloaded {
-                        [&](BuildableOpaque bo) {
+                        [&](DerivedPathOpaque bo) {
                             std::string symlink = outLink;
                             if (i) symlink += fmt("-%d", i);
                             store2->addPermRoot(bo.path, absPath(symlink));
                         },
-                        [&](BuildableFromDrv bfd) {
+                        [&](DerivedPathWithHintsBuilt bfd) {
                             auto builtOutputs = store->queryDerivationOutputMap(bfd.drvPath);
                             for (auto & output : builtOutputs) {
                                 std::string symlink = outLink;
@@ -80,7 +80,7 @@ struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
 
         updateProfile(buildables);
 
-        if (json) logger->cout("%s", buildablesToJSON(buildables, store).dump());
+        if (json) logger->cout("%s", derivedPathsWithHintsToJSON(buildables, store).dump());
     }
 };
 
diff --git a/src/nix/bundle.cc b/src/nix/bundle.cc
index e86fbb3f7..53dccc63a 100644
--- a/src/nix/bundle.cc
+++ b/src/nix/bundle.cc
@@ -70,7 +70,7 @@ struct CmdBundle : InstallableCommand
         auto evalState = getEvalState();
 
         auto app = installable->toApp(*evalState);
-        store->buildPaths(toBuildableReqs(app.context));
+        store->buildPaths(toDerivedPaths(app.context));
 
         auto [bundlerFlakeRef, bundlerName] = parseFlakeRefWithFragment(bundler, absPath("."));
         const flake::LockFlags lockFlags{ .writeLockFile = false };
@@ -110,7 +110,7 @@ struct CmdBundle : InstallableCommand
 
         StorePath outPath = store->parseStorePath(evalState->coerceToPath(*attr2->pos, *attr2->value, context2));
 
-        store->buildPaths({ BuildableReqFromDrv { drvPath } });
+        store->buildPaths({ DerivedPath::Built { drvPath } });
 
         auto outPathS = store->printStorePath(outPath);
 
diff --git a/src/nix/develop.cc b/src/nix/develop.cc
index 616e2073e..cae6ded40 100644
--- a/src/nix/develop.cc
+++ b/src/nix/develop.cc
@@ -160,7 +160,7 @@ StorePath getDerivationEnvironment(ref<Store> store, const StorePath & drvPath)
     auto shellDrvPath = writeDerivation(*store, drv);
 
     /* Build the derivation. */
-    store->buildPaths({BuildableReqFromDrv{shellDrvPath}});
+    store->buildPaths({DerivedPath::Built{shellDrvPath}});
 
     for (auto & [_0, outputAndOptPath] : drv.outputsAndOptPaths(*store)) {
         auto & [_1, optPath] = outputAndOptPath;
@@ -265,7 +265,7 @@ struct Common : InstallableCommand, MixProfile
         for (auto & [installable_, dir_] : redirects) {
             auto dir = absPath(dir_);
             auto installable = parseInstallable(store, installable_);
-            auto buildable = installable->toBuildable();
+            auto buildable = installable->toDerivedPathWithHints();
             auto doRedirect = [&](const StorePath & path)
             {
                 auto from = store->printStorePath(path);
@@ -277,10 +277,10 @@ struct Common : InstallableCommand, MixProfile
                 }
             };
             std::visit(overloaded {
-                [&](const BuildableOpaque & bo) {
+                [&](const DerivedPathOpaque & bo) {
                     doRedirect(bo.path);
                 },
-                [&](const BuildableFromDrv & bfd) {
+                [&](const DerivedPathWithHintsBuilt & bfd) {
                     for (auto & [outputName, path] : bfd.outputs)
                         if (path) doRedirect(*path);
                 },
diff --git a/src/nix/flake.cc b/src/nix/flake.cc
index 9d6d22a43..62a413e27 100644
--- a/src/nix/flake.cc
+++ b/src/nix/flake.cc
@@ -293,7 +293,7 @@ struct CmdFlakeCheck : FlakeCommand
             }
         };
 
-        std::vector<BuildableReq> drvPaths;
+        std::vector<DerivedPath> drvPaths;
 
         auto checkApp = [&](const std::string & attrPath, Value & v, const Pos & pos) {
             try {
@@ -462,7 +462,7 @@ struct CmdFlakeCheck : FlakeCommand
                                         fmt("%s.%s.%s", name, attr.name, attr2.name),
                                         *attr2.value, *attr2.pos);
                                     if ((std::string) attr.name == settings.thisSystem.get())
-                                        drvPaths.push_back(BuildableReqFromDrv{drvPath});
+                                        drvPaths.push_back(DerivedPath::Built{drvPath});
                                 }
                             }
                         }
diff --git a/src/nix/log.cc b/src/nix/log.cc
index 67d3742d6..5010e3326 100644
--- a/src/nix/log.cc
+++ b/src/nix/log.cc
@@ -30,15 +30,15 @@ struct CmdLog : InstallableCommand
 
         subs.push_front(store);
 
-        auto b = installable->toBuildable();
+        auto b = installable->toDerivedPathWithHints();
 
         RunPager pager;
         for (auto & sub : subs) {
             auto log = std::visit(overloaded {
-                [&](BuildableOpaque bo) {
+                [&](DerivedPathOpaque bo) {
                     return sub->getBuildLog(bo.path);
                 },
-                [&](BuildableFromDrv bfd) {
+                [&](DerivedPathWithHintsBuilt bfd) {
                     return sub->getBuildLog(bfd.drvPath);
                 },
             }, b);
diff --git a/src/nix/profile.cc b/src/nix/profile.cc
index b96e71844..ad824dd70 100644
--- a/src/nix/profile.cc
+++ b/src/nix/profile.cc
@@ -233,7 +233,7 @@ struct CmdProfileInstall : InstallablesCommand, MixDefaultProfile
     {
         ProfileManifest manifest(*getEvalState(), *profile);
 
-        std::vector<BuildableReq> pathsToBuild;
+        std::vector<DerivedPath> pathsToBuild;
 
         for (auto & installable : installables) {
             if (auto installable2 = std::dynamic_pointer_cast<InstallableFlake>(installable)) {
@@ -249,7 +249,7 @@ struct CmdProfileInstall : InstallablesCommand, MixDefaultProfile
                     attrPath,
                 };
 
-                pathsToBuild.push_back(BuildableReqFromDrv{drv.drvPath, StringSet{drv.outputName}});
+                pathsToBuild.push_back(DerivedPath::Built{drv.drvPath, StringSet{drv.outputName}});
 
                 manifest.elements.emplace_back(std::move(element));
             } else {
@@ -259,16 +259,16 @@ struct CmdProfileInstall : InstallablesCommand, MixDefaultProfile
                     ProfileElement element;
 
                     std::visit(overloaded {
-                        [&](BuildableOpaque bo) {
+                        [&](DerivedPathOpaque bo) {
                             pathsToBuild.push_back(bo);
                             element.storePaths.insert(bo.path);
                         },
-                        [&](BuildableFromDrv bfd) {
+                        [&](DerivedPathWithHintsBuilt bfd) {
                             // TODO: Why are we querying if we know the output
                             // names already? Is it just to figure out what the
                             // default one is?
                             for (auto & output : store->queryDerivationOutputMap(bfd.drvPath)) {
-                                pathsToBuild.push_back(BuildableReqFromDrv{bfd.drvPath, {output.first}});
+                                pathsToBuild.push_back(DerivedPath::Built{bfd.drvPath, {output.first}});
                                 element.storePaths.insert(output.second);
                             }
                         },
@@ -391,7 +391,7 @@ struct CmdProfileUpgrade : virtual SourceExprCommand, MixDefaultProfile, MixProf
         auto matchers = getMatchers(store);
 
         // FIXME: code duplication
-        std::vector<BuildableReq> pathsToBuild;
+        std::vector<DerivedPath> pathsToBuild;
 
         for (size_t i = 0; i < manifest.elements.size(); ++i) {
             auto & element(manifest.elements[i]);
@@ -426,7 +426,7 @@ struct CmdProfileUpgrade : virtual SourceExprCommand, MixDefaultProfile, MixProf
                     attrPath,
                 };
 
-                pathsToBuild.push_back(BuildableReqFromDrv{drv.drvPath, {"out"}}); // FIXME
+                pathsToBuild.push_back(DerivedPath::Built{drv.drvPath, {"out"}}); // FIXME
             }
         }
 
diff --git a/src/nix/run.cc b/src/nix/run.cc
index 2e9bb41cc..ba60e57d8 100644
--- a/src/nix/run.cc
+++ b/src/nix/run.cc
@@ -182,7 +182,7 @@ struct CmdRun : InstallableCommand, RunCommon
 
         auto app = installable->toApp(*state);
 
-        state->store->buildPaths(toBuildableReqs(app.context));
+        state->store->buildPaths(toDerivedPaths(app.context));
 
         Strings allArgs{app.program};
         for (auto & i : args) allArgs.push_back(i);