Implemented --flake flag for nix build

Also fixed Eelco's PR comments

src/libexpr/primops/flake.cc

@@ -3,7 +3,9 @@
 #include "eval-inline.hh"
 #include "fetchGit.hh"
 #include "download.hh"
+#include "args.hh"
 
+#include <iostream>
 #include <queue>
 #include <regex>
 #include <nlohmann/json.hpp>
@@ -32,10 +34,10 @@ static std::unique_ptr<FlakeRegistry> readRegistry(const Path & path)
 }
 
 /* Write the registry or lock file to a file. */
-static void writeRegistry(FlakeRegistry registry, Path path = "./flake.lock")
+void writeRegistry(FlakeRegistry registry, Path path)
 {
     nlohmann::json json = {};
-    json["value"] = 0; // Not sure whether this should be 0.
+    json["version"] = 1;
     json["flakes"] = {};
     for (auto elem : registry.entries) {
         json["flakes"][elem.first] = elem.second.ref.to_string();
@@ -107,9 +109,21 @@ struct FlakeSourceInfo
 
 static FlakeSourceInfo fetchFlake(EvalState & state, const FlakeRef & flakeRef)
 {
-    assert(flakeRef.isDirect());
+    FlakeRef directFlakeRef = FlakeRef(flakeRef);
+    if (!flakeRef.isDirect())
+    {
+        std::vector<const FlakeRegistry *> registries;
+        // 'pureEval' is a setting which cannot be changed in `nix flake`,
+        // but without flagging it off, we can't use any FlakeIds.
+        // if (!evalSettings.pureEval) {
+            registries.push_back(&state.getFlakeRegistry());
+        // }
+        directFlakeRef = lookupFlake(state, flakeRef, registries);
+    }
+    assert(directFlakeRef.isDirect());
+    // NOTE FROM NICK: I don't see why one wouldn't fetch FlakeId flakes..
 
-    if (auto refData = std::get_if<FlakeRef::IsGitHub>(&flakeRef.data)) {
+    if (auto refData = std::get_if<FlakeRef::IsGitHub>(&directFlakeRef.data)) {
         // FIXME: require hash in pure mode.
 
         // FIXME: use regular /archive URLs instead? api.github.com
@@ -141,7 +155,7 @@ static FlakeSourceInfo fetchFlake(EvalState & state, const FlakeRef & flakeRef)
         return info;
     }
 
-    else if (auto refData = std::get_if<FlakeRef::IsGit>(&flakeRef.data)) {
+    else if (auto refData = std::get_if<FlakeRef::IsGit>(&directFlakeRef.data)) {
         auto gitInfo = exportGit(state.store, refData->uri, refData->ref,
             refData->rev ? refData->rev->to_string(Base16, false) : "", "source");
         FlakeSourceInfo info;
@@ -165,7 +179,16 @@ Flake getFlake(EvalState & state, const FlakeRef & flakeRef)
     if (state.allowedPaths)
         state.allowedPaths->insert(flakePath);
 
-    Flake flake;
+    FlakeRef newFlakeRef(flakeRef);
+    if (std::get_if<FlakeRef::IsGitHub>(&newFlakeRef.data)) {
+        FlakeSourceInfo srcInfo = fetchFlake(state, newFlakeRef);
+        if (srcInfo.rev) {
+            std::string uri = flakeRef.to_string();
+            newFlakeRef = FlakeRef(uri + "/" + srcInfo.rev->to_string());
+        }
+    }
+
+    Flake flake(newFlakeRef);
 
     Value vInfo;
     state.evalFile(flakePath + "/flake.nix", vInfo); // FIXME: symlink attack
@@ -258,6 +281,35 @@ static std::tuple<FlakeId, std::map<FlakeId, Flake>> resolveFlake(EvalState & st
     return {*topFlakeId, std::move(done)};
 }
 
+FlakeRegistry updateLockFile(EvalState & evalState, FlakeRef & flakeRef)
+{
+    FlakeRegistry newLockFile;
+    std::map<FlakeId, Flake> myDependencyMap = get<1>(resolveFlake(evalState, flakeRef, false));
+    // Nick assumed that "topRefPure" means that the Flake for flakeRef can be
+    // fetched purely.
+    for (auto const& require : myDependencyMap) {
+        FlakeRegistry::Entry entry = FlakeRegistry::Entry(require.second.ref);
+        // The FlakeRefs are immutable because they come out of the Flake objects,
+        // not from the requires.
+        newLockFile.entries.insert(std::pair<FlakeId, FlakeRegistry::Entry>(require.first, entry));
+    }
+    return newLockFile;
+}
+
+void updateLockFile(EvalState & state, std::string path)
+{
+    // 'path' is the path to the local flake repo.
+    FlakeRef flakeRef = FlakeRef(path);
+    if (std::get_if<FlakeRef::IsGit>(&flakeRef.data)) {
+        FlakeRegistry newLockFile = updateLockFile(state, flakeRef);
+        writeRegistry(newLockFile, path + "/flake.lock");
+    } else if (std::get_if<FlakeRef::IsGitHub>(&flakeRef.data)) {
+        throw UsageError("You can only update local flakes, not flakes on GitHub.");
+    } else {
+       throw UsageError("You can only update local flakes, not flakes through their FlakeId.");
+    }
+}
+
 Value * makeFlakeValue(EvalState & state, std::string flakeUri, Value & v)
 {
     // FIXME: temporary hack to make the default installation source

src/libexpr/primops/flake.hh

@@ -13,6 +13,7 @@ struct FlakeRegistry
     struct Entry
     {
         FlakeRef ref;
+        Entry(const FlakeRef & flakeRef) : ref(flakeRef) {};
     };
     std::map<FlakeId, Entry> entries;
 };
@@ -21,9 +22,12 @@ Value * makeFlakeRegistryValue(EvalState & state);
 
 Value * makeFlakeValue(EvalState & state, std::string flakeUri, Value & v);
 
+void writeRegistry(FlakeRegistry, Path);
+
 struct Flake
 {
     FlakeId id;
+    FlakeRef ref;
     std::string description;
     Path path;
     std::vector<FlakeRef> requires;
@@ -32,9 +36,12 @@ struct Flake
     // commit hash
     // date
     // content hash
+    Flake(FlakeRef & flakeRef) : ref(flakeRef) {};
 };
 
-Flake getFlake(EvalState & state, const FlakeRef & flakeRef);
+Flake getFlake(EvalState &, const FlakeRef &);
 
-void writeRegistry(FlakeRegistry);
+FlakeRegistry updateLockFile(EvalState &, Flake &);
+
+void updateLockFile(EvalState &, std::string);
 }

src/libexpr/primops/flakeref.hh

@@ -129,6 +129,9 @@ struct FlakeRef
     // Parse a flake URI.
     FlakeRef(const std::string & uri);
 
+    // Default constructor
+    FlakeRef(const FlakeRef & flakeRef) : data(flakeRef.data) {};
+
     /* Unify two flake references so that the resulting reference
        combines the information from both. For example,
        "nixpkgs/<hash>" and "github:NixOS/nixpkgs" unifies to