Make ParseSink a bit better

I wouldn't call it *good* yet, but this will do for now.

- `RetrieveRegularNARSink` renamed to `RegularFileSink` and moved
  accordingly because it actually has nothing to do with NARs in
  particular.

  - its `fd` field is also marked private

- `copyRecursive` introduced to dump a `SourceAccessor` into a
  `ParseSink`.

- `NullParseSink` made so `ParseSink` no longer has sketchy default
  methods.

This was done while updating #8918 to work with the new
`SourceAccessor`.

src/libutil/fs-sink.hh

@@ -3,6 +3,7 @@
 
 #include "types.hh"
 #include "serialise.hh"
+#include "source-accessor.hh"
 
 namespace nix {
 
@@ -11,32 +12,93 @@ namespace nix {
  */
 struct ParseSink
 {
-    virtual void createDirectory(const Path & path) { };
+    virtual void createDirectory(const Path & path) = 0;
 
-    virtual void createRegularFile(const Path & path) { };
-    virtual void closeRegularFile() { };
-    virtual void isExecutable() { };
+    virtual void createRegularFile(const Path & path) = 0;
+    virtual void receiveContents(std::string_view data) = 0;
+    virtual void isExecutable() = 0;
+    virtual void closeRegularFile() = 0;
+
+    virtual void createSymlink(const Path & path, const std::string & target) = 0;
+
+    /**
+     * An optimization. By default, do nothing.
+     */
     virtual void preallocateContents(uint64_t size) { };
-    virtual void receiveContents(std::string_view data) { };
-
-    virtual void createSymlink(const Path & path, const std::string & target) { };
 };
 
+/**
+ * Recusively copy file system objects from the source into the sink.
+ */
+void copyRecursive(
+    SourceAccessor & accessor, const CanonPath & sourcePath,
+    ParseSink & sink, const Path & destPath);
+
+/**
+ * Ignore everything and do nothing
+ */
+struct NullParseSink : ParseSink
+{
+    void createDirectory(const Path & path) override { }
+    void receiveContents(std::string_view data) override { }
+    void createSymlink(const Path & path, const std::string & target) override { }
+    void createRegularFile(const Path & path) override { }
+    void closeRegularFile() override { }
+    void isExecutable() override { }
+};
+
+/**
+ * Write files at the given path
+ */
 struct RestoreSink : ParseSink
 {
     Path dstPath;
-    AutoCloseFD fd;
-
 
     void createDirectory(const Path & path) override;
 
     void createRegularFile(const Path & path) override;
-    void closeRegularFile() override;
-    void isExecutable() override;
-    void preallocateContents(uint64_t size) override;
     void receiveContents(std::string_view data) override;
+    void isExecutable() override;
+    void closeRegularFile() override;
 
     void createSymlink(const Path & path, const std::string & target) override;
+
+    void preallocateContents(uint64_t size) override;
+
+private:
+    AutoCloseFD fd;
+};
+
+/**
+ * Restore a single file at the top level, passing along
+ * `receiveContents` to the underlying `Sink`. For anything but a single
+ * file, set `regular = true` so the caller can fail accordingly.
+ */
+struct RegularFileSink : ParseSink
+{
+    bool regular = true;
+    Sink & sink;
+
+    RegularFileSink(Sink & sink) : sink(sink) { }
+
+    void createDirectory(const Path & path) override
+    {
+        regular = false;
+    }
+
+    void receiveContents(std::string_view data) override
+    {
+        sink(data);
+    }
+
+    void createSymlink(const Path & path, const std::string & target) override
+    {
+        regular = false;
+    }
+
+    void createRegularFile(const Path & path) override { }
+    void closeRegularFile() override { }
+    void isExecutable() override { }
 };
 
 }