* Get garbage collection and cache population to work *properly*.

  Renamed `fstateRefs' to `fstateRequisites'.  The semantics of this
  function is that it returns a list of all paths necessary to realise
  a given expression.  For a derive expression, this is the union of
  requisites of the inputs; for a slice expression, it is the path of
  each element in the slice.  Also included are the paths of the
  expressions themselves.  Optionally, one can also include the
  requisites of successor expressions (to recycle intermediate
  results).

* `nix-switch' now distinguishes between an expression and its normal
  form.  Usually, only the normal form is registered as a root of the
  garbage collector.  With the `--source-root' flag, it will also
  register the original expression as a root.

* `nix-collect-garbage' now has a flag `--keep-successors' which
  causes successors not to be included in the list of garbage paths.

* `nix-collect-garbage' now has a flag `--invert' which will print all
  paths that should *not* be garbage collected.

5 files changed, 36 insertions, 12 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 23e2429191ac..cc51eff36577 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -43,6 +43,7 @@ nix.o: nix-help.txt.hh
 install-data-local:
 	$(INSTALL) -d $(localstatedir)/nix
 	$(INSTALL) -d $(localstatedir)/nix/links
+	ln -sf $(localstatedir)/nix/links/current $(prefix)/current
 	$(INSTALL) -d $(localstatedir)/log/nix
 	$(INSTALL) -d $(prefix)/store
 	$(bindir)/nix --init
diff --git a/src/nix-help.txt b/src/nix-help.txt
index ecf9b5c16d25..0e54d162de05 100644
--- a/src/nix-help.txt
+++ b/src/nix-help.txt
@@ -26,7 +26,7 @@ Source selection for --install, --dump:
 Query flags:
 
   --list / -l: query the output paths (roots) of an fstate (default)
-  --refs / -r: query paths referenced by an fstate
+  --requisites / -r: print all paths necessary to realise expression
   --generators / -g: find expressions producing a subset of given ids
   --expansion / -e: print a path containing id
   --graph: print a dot graph rooted at given ids
diff --git a/src/nix.cc b/src/nix.cc
index a7bcf7268413..68d01f2f87a3 100644
--- a/src/nix.cc
+++ b/src/nix.cc
@@ -95,18 +95,22 @@ FSId maybeNormalise(const FSId & id, bool normalise)
 /* Perform various sorts of queries. */
 static void opQuery(Strings opFlags, Strings opArgs)
 {
-    enum { qList, qRefs, qGenerators, qExpansion, qGraph 
+    enum { qList, qRequisites, qGenerators, qExpansion, qGraph 
     } query = qList;
     bool normalise = false;
+    bool includeExprs = true;
+    bool includeSuccessors = false;
 
     for (Strings::iterator i = opFlags.begin();
          i != opFlags.end(); i++)
         if (*i == "--list" || *i == "-l") query = qList;
-        else if (*i == "--refs" || *i == "-r") query = qRefs;
+        else if (*i == "--requisites" || *i == "-r") query = qRequisites;
         else if (*i == "--generators" || *i == "-g") query = qGenerators;
         else if (*i == "--expansion" || *i == "-e") query = qExpansion;
         else if (*i == "--graph") query = qGraph;
         else if (*i == "--normalise" || *i == "-n") normalise = true;
+        else if (*i == "--exclude-exprs") includeExprs = false;
+        else if (*i == "--include-successors") includeSuccessors = true;
         else throw UsageError(format("unknown flag `%1%'") % *i);
 
     switch (query) {
@@ -126,13 +130,14 @@ static void opQuery(Strings opFlags, Strings opArgs)
             break;
         }
 
-        case qRefs: {
+        case qRequisites: {
             StringSet paths;
             for (Strings::iterator i = opArgs.begin();
                  i != opArgs.end(); i++)
             {
-                Strings paths2 = fstateRefs(
-                    maybeNormalise(argToId(*i), normalise));
+                Strings paths2 = fstateRequisites(
+                    maybeNormalise(argToId(*i), normalise),
+                    includeExprs, includeSuccessors);
                 paths.insert(paths2.begin(), paths2.end());
             }
             for (StringSet::iterator i = paths.begin(); 
diff --git a/src/normalise.cc b/src/normalise.cc
index eefb790b6f98..5ef4d82ac139 100644
--- a/src/normalise.cc
+++ b/src/normalise.cc
@@ -244,7 +244,8 @@ Strings fstatePaths(const FSId & id)
 }
 
 
-static void fstateRefsSet(const FSId & id, StringSet & paths)
+static void fstateRequisitesSet(const FSId & id, 
+    bool includeExprs, bool includeSuccessors, StringSet & paths)
 {
     FState fs = parseFState(termFromId(id));
 
@@ -257,17 +258,28 @@ static void fstateRefsSet(const FSId & id, StringSet & paths)
     else if (fs.type == FState::fsDerive) {
         for (FSIds::iterator i = fs.derive.inputs.begin();
              i != fs.derive.inputs.end(); i++)
-            fstateRefsSet(*i, paths);
+            fstateRequisitesSet(*i,
+                includeExprs, includeSuccessors, paths);
     }
 
     else abort();
+
+    if (includeExprs) 
+        paths.insert(expandId(id));
+
+    string idSucc;
+    if (includeSuccessors &&
+        queryDB(nixDB, dbSuccessors, id, idSucc))
+        fstateRequisitesSet(parseHash(idSucc), 
+            includeExprs, includeSuccessors, paths);
 }
 
 
-Strings fstateRefs(const FSId & id)
+Strings fstateRequisites(const FSId & id,
+    bool includeExprs, bool includeSuccessors)
 {
     StringSet paths;
-    fstateRefsSet(id, paths);
+    fstateRequisitesSet(id, includeExprs, includeSuccessors, paths);
     return Strings(paths.begin(), paths.end());
 }
 
diff --git a/src/normalise.hh b/src/normalise.hh
index a5b45c861926..98f58783e5b8 100644
--- a/src/normalise.hh
+++ b/src/normalise.hh
@@ -15,8 +15,14 @@ void realiseSlice(const FSId & id, FSIdSet pending = FSIdSet());
    fstate-expression. */
 Strings fstatePaths(const FSId & id);
 
-/* Get the list of paths referenced by the given fstate-expression. */
-Strings fstateRefs(const FSId & id);
+/* Get the list of paths that are required to realise the given
+   expression.  For a derive expression, this is the union of
+   requisites of the inputs; for a slice expression, it is the path of
+   each element in the slice.  If `includeExprs' is true, include the
+   paths of the Nix expressions themselves.  If `includeSuccessors' is
+   true, include the requisites of successors. */
+Strings fstateRequisites(const FSId & id,
+    bool includeExprs, bool includeSuccessors);
 
 /* Return the list of the ids of all known fstate-expressions whose
    output ids are completely contained in `ids'. */