Allow flake inputs to be fetched at build time

This only works for non-flake inputs. Example:

  inputs.repo1 = {
    type = "github";
    owner = "DeterminateSystems";
    repo = "blabla";
    flake = false;
    buildTime = true;
  };

`call-flake.nix` maps this to a builtin:fetch-tree derivation. Thus
you can pass it to other derivations, and it will be fetched at build
time rather than eval time. (It will still be fetched at eval time to
create/update locks.) Importing from such an input triggers IFD.

Author: edolstra

src/libflake/call-flake.nix

@@ -50,7 +50,17 @@ let
         if node ? parent then parentDir + ("/" + dir) else dir;
 
       sourceInfo =
-        if overrides ? ${key} then
+        if node.buildTime or false then
+          derivation {
+            name = "source";
+            builder = "builtin:fetch-tree";
+            system = "builtin";
+            __structuredAttrs = true;
+            input = node.locked;
+            outputHashMode = "recursive";
+            outputHash = node.locked.narHash;
+          }
+        else if overrides ? ${key} then
           overrides.${key}.sourceInfo
         else if node.locked.type == "path" && builtins.substring 0 1 node.locked.path != "/" then
           parentNode.sourceInfo
@@ -97,6 +107,7 @@ let
       result =
         if node.flake or true then
           assert builtins.isFunction flake.outputs;
+          assert !(node.buildTime or false);
           result
         else
           sourceInfo;

src/libflake/flake.cc

@@ -99,6 +99,7 @@ static FlakeInput parseFlakeInput(
     auto sUrl = state.symbols.create("url");
     auto sFlake = state.symbols.create("flake");
     auto sFollows = state.symbols.create("follows");
+    auto sBuildTime = state.symbols.create("buildTime");
 
     fetchers::Attrs attrs;
     std::optional<std::string> url;
@@ -123,6 +124,9 @@ static FlakeInput parseFlakeInput(
             } else if (attr.name == sFlake) {
                 expectType(state, nBool, *attr.value, attr.pos);
                 input.isFlake = attr.value->boolean();
+            } else if (attr.name == sBuildTime) {
+                expectType(state, nBool, *attr.value, attr.pos);
+                input.buildTime = attr.value->boolean();
             } else if (attr.name == sInputs) {
                 input.overrides = parseFlakeInputs(state, attr.value, attr.pos, lockRootAttrPath, flakeDir, false).first;
             } else if (attr.name == sFollows) {
@@ -593,6 +597,7 @@ LockedFlake lockFlake(
                             oldLock->lockedRef,
                             oldLock->originalRef,
                             oldLock->isFlake,
+                            oldLock->buildTime,
                             oldLock->parentInputAttrPath);
 
                         node->inputs.insert_or_assign(id, childNode);
@@ -702,6 +707,7 @@ LockedFlake lockFlake(
                                 inputFlake.lockedRef,
                                 ref,
                                 true,
+                                input.buildTime,
                                 overridenParentPath);
 
                             node->inputs.insert_or_assign(id, childNode);
@@ -751,7 +757,7 @@ LockedFlake lockFlake(
                                 }
                             }();
 
-                            auto childNode = make_ref<LockedNode>(lockedRef, ref, false, overridenParentPath);
+                            auto childNode = make_ref<LockedNode>(lockedRef, ref, false, input.buildTime, overridenParentPath);
 
                             nodePaths.emplace(childNode, path);
 

src/libflake/include/nix/flake/flake.hh

@@ -43,12 +43,18 @@ typedef std::map<FlakeId, FlakeInput> FlakeInputs;
 struct FlakeInput
 {
     std::optional<FlakeRef> ref;
+
     /**
-     * true = process flake to get outputs
-     *
-     * false = (fetched) static source path
+     * Whether to call the `flake.nix` file in this input to get its outputs.
      */
     bool isFlake = true;
+
+    /**
+     * Whether to fetch this input at evaluation time or at build
+     * time.
+     */
+    bool buildTime = false;
+
     std::optional<InputAttrPath> follows;
     FlakeInputs overrides;
 };

src/libflake/include/nix/flake/lockfile.hh

@@ -37,6 +37,7 @@ struct LockedNode : Node
 {
     FlakeRef lockedRef, originalRef;
     bool isFlake = true;
+    bool buildTime = false;
 
     /* The node relative to which relative source paths
        (e.g. 'path:../foo') are interpreted. */
@@ -46,10 +47,12 @@ struct LockedNode : Node
         const FlakeRef & lockedRef,
         const FlakeRef & originalRef,
         bool isFlake = true,
+        bool buildTime = false,
         std::optional<InputAttrPath> parentInputAttrPath = {})
         : lockedRef(std::move(lockedRef))
         , originalRef(std::move(originalRef))
         , isFlake(isFlake)
+        , buildTime(buildTime)
         , parentInputAttrPath(std::move(parentInputAttrPath))
     { }
 

src/libflake/lockfile.cc

@@ -44,6 +44,7 @@ LockedNode::LockedNode(
     : lockedRef(getFlakeRef(fetchSettings, json, "locked", "info")) // FIXME: remove "info"
     , originalRef(getFlakeRef(fetchSettings, json, "original", nullptr))
     , isFlake(json.find("flake") != json.end() ? (bool) json["flake"] : true)
+    , buildTime(json.find("buildTime") != json.end() ? (bool) json["buildTime"] : false)
     , parentInputAttrPath(json.find("parent") != json.end() ? (std::optional<InputAttrPath>) json["parent"] : std::nullopt)
 {
     if (!lockedRef.input.isLocked() && !lockedRef.input.isRelative()) {
@@ -216,6 +217,8 @@ std::pair<nlohmann::json, LockFile::KeyMap> LockFile::toJSON() const
             n["locked"].erase("__final");
             if (!lockedNode->isFlake)
                 n["flake"] = false;
+            if (lockedNode->buildTime)
+                n["buildTime"] = true;
             if (lockedNode->parentInputAttrPath)
                 n["parent"] = *lockedNode->parentInputAttrPath;
         }