Add --include-build-refs to `nix path-info' command

src/libexpr/eval.hh

@@ -19,6 +19,7 @@ namespace nix {
 class Store;
 class EvalState;
 struct StorePath;
+struct StorePathWithOutputs;
 enum RepairFlag : bool;
 
 
@@ -89,6 +90,9 @@ public:
 
     const ref<Store> store;
 
+    /* List of derivations that got imported. */
+    std::vector<StorePathWithOutputs> importedDrvs;
+
 private:
     SrcToStore srcToStore;
 

src/libexpr/primops.cc

@@ -56,6 +56,7 @@ void EvalState::realiseContext(const PathSet & context)
             throw InvalidPathError(store->printStorePath(ctx));
         if (!decoded.second.empty() && ctx.isDerivation()) {
             drvs.push_back(StorePathWithOutputs{ctx.clone(), {decoded.second}});
+            importedDrvs.push_back(StorePathWithOutputs{ctx.clone(), {decoded.second}});
 
             /* Add the output of this derivation to the allowed
                paths. */

src/nix/command.cc

@@ -2,6 +2,7 @@
 #include "store-api.hh"
 #include "derivations.hh"
 #include "nixexpr.hh"
+#include "eval.hh"
 #include "profiles.hh"
 
 extern char * * environ;
@@ -47,6 +48,10 @@ StorePathsCommand::StorePathsCommand(bool recursive)
             .set(&this->recursive, true);
 
     mkFlag(0, "all", "apply operation to the entire store", &all);
+
+    // these options only make sense when recursing
+    mkFlag('b', "build", "include build dependencies of specified path", &includeBuildDeps);
+    mkFlag('e', "eval", "include eval dependencies of specified path", &includeEvalDeps);
 }
 
 void StorePathsCommand::run(ref<Store> store)
@@ -61,15 +66,49 @@ void StorePathsCommand::run(ref<Store> store)
     }
 
     else {
+        if (!recursive && (includeBuildDeps || includeEvalDeps))
+            throw UsageError("--build and --eval require --recursive");
+
         for (auto & p : toStorePaths(store, realiseMode, installables))
             storePaths.push_back(p.clone());
 
         if (recursive) {
+            if (includeEvalDeps)
+                for (auto & i : installables) {
+                    auto state = getEvalState();
+
+                    for (auto & b : i->toBuildables())
+                        if (!b.drvPath)
+                            throw UsageError("Cannot find eval references for '%s' without a derivation path", b.what());
+
+                    // force evaluation of package argument
+                    i->toValue(*state);
+
+                    for (auto & d : (*state).importedDrvs)
+                        storePaths.push_back(std::move(d.path));
+                }
+
+            if (includeBuildDeps)
+                for (auto & i : installables)
+                    for (auto & b : i->toBuildables()) {
+                        if (!b.drvPath) {
+                            auto info = store->queryPathInfo(b.outputs.at("out"));
+                            if (info->deriver)
+                                storePaths.push_back(info->deriver->clone());
+                            else
+                                throw UsageError("Cannot find build references for '%s' without a derivation path", b.what());
+                        } else
+                            storePaths.push_back(b.drvPath->clone());
+                    }
+
+            auto includeDerivers = includeBuildDeps || includeEvalDeps;
+
             StorePathSet closure;
-            store->computeFSClosure(storePathsToSet(storePaths), closure, false, false);
+            store->computeFSClosure(storePathsToSet(storePaths), closure, false, includeDerivers);
             storePaths.clear();
             for (auto & p : closure)
-                storePaths.push_back(p.clone());
+                if (!(includeDerivers && p.isDerivation()))
+                    storePaths.push_back(p.clone());
         }
     }
 

src/nix/command.hh

@@ -91,6 +91,9 @@ private:
     bool recursive = false;
     bool all = false;
 
+    bool includeBuildDeps = false;
+    bool includeEvalDeps = false;
+
 protected:
 
     RealiseMode realiseMode = NoBuild;

src/nix/installables.hh

@@ -12,6 +12,10 @@ struct Buildable
 {
     std::optional<StorePath> drvPath;
     std::map<std::string, StorePath> outputs;
+
+    std::string what() {
+        return fmt("%s", outputs.at("out").name());
+    }
 };
 
 typedef std::vector<Buildable> Buildables;