C API: (breaking) remove nix-flake-c global init

src/libflake/flake/flake-primops.cc

@@ -0,0 +1,59 @@
+#include "flake-primops.hh"
+#include "eval.hh"
+#include "flake.hh"
+#include "flakeref.hh"
+#include "settings.hh"
+
+namespace nix::flake::primops {
+
+PrimOp getFlake(const Settings & settings)
+{
+    auto prim_getFlake = [&settings](EvalState & state, const PosIdx pos, Value ** args, Value & v) {
+        std::string flakeRefS(
+            state.forceStringNoCtx(*args[0], pos, "while evaluating the argument passed to builtins.getFlake"));
+        auto flakeRef = nix::parseFlakeRef(state.fetchSettings, flakeRefS, {}, true);
+        if (state.settings.pureEval && !flakeRef.input.isLocked())
+            throw Error(
+                "cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)",
+                flakeRefS,
+                state.positions[pos]);
+
+        callFlake(
+            state,
+            lockFlake(
+                settings,
+                state,
+                flakeRef,
+                LockFlags{
+                    .updateLockFile = false,
+                    .writeLockFile = false,
+                    .useRegistries = !state.settings.pureEval && settings.useRegistries,
+                    .allowUnlocked = !state.settings.pureEval,
+                }),
+            v);
+    };
+
+    return PrimOp{
+        .name = "__getFlake",
+        .args = {"args"},
+        .doc = R"(
+          Fetch a flake from a flake reference, and return its output attributes and some metadata. For example:
+
+          ```nix
+          (builtins.getFlake "nix/55bc52401966fbffa525c574c14f67b00bc4fb3a").packages.x86_64-linux.nix
+          ```
+
+          Unless impure evaluation is allowed (`--impure`), the flake reference
+          must be "locked", e.g. contain a Git revision or content hash. An
+          example of an unlocked usage is:
+
+          ```nix
+          (builtins.getFlake "github:edolstra/dwarffs").rev
+          ```
+        )",
+        .fun = prim_getFlake,
+        .experimentalFeature = Xp::Flakes,
+    };
+}
+
+} // namespace nix::flake::primops

src/libflake/flake/flake-primops.hh

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "eval.hh"
+#include "flake/settings.hh"
+
+namespace nix::flake::primops {
+
+/**
+ * Returns a `builtins.getFlake` primop with the given nix::flake::Settings.
+ */
+nix::PrimOp getFlake(const Settings & settings);
+
+} // namespace nix::flake

src/libflake/flake/flake.cc

@@ -973,49 +973,6 @@ void callFlake(EvalState & state,
     state.callFunction(*vCallFlake, args, vRes, noPos);
 }
 
-void initLib(const Settings & settings)
-{
-    auto prim_getFlake = [&settings](EvalState & state, const PosIdx pos, Value * * args, Value & v)
-    {
-        std::string flakeRefS(state.forceStringNoCtx(*args[0], pos, "while evaluating the argument passed to builtins.getFlake"));
-        auto flakeRef = parseFlakeRef(state.fetchSettings, flakeRefS, {}, true);
-        if (state.settings.pureEval && !flakeRef.input.isLocked())
-            throw Error("cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)", flakeRefS, state.positions[pos]);
-
-        callFlake(state,
-            lockFlake(settings, state, flakeRef,
-                LockFlags {
-                    .updateLockFile = false,
-                    .writeLockFile = false,
-                    .useRegistries = !state.settings.pureEval && settings.useRegistries,
-                    .allowUnlocked = !state.settings.pureEval,
-                }),
-            v);
-    };
-
-    RegisterPrimOp::primOps->push_back({
-        .name =  "__getFlake",
-        .args = {"args"},
-        .doc = R"(
-          Fetch a flake from a flake reference, and return its output attributes and some metadata. For example:
-
-          ```nix
-          (builtins.getFlake "nix/55bc52401966fbffa525c574c14f67b00bc4fb3a").packages.x86_64-linux.nix
-          ```
-
-          Unless impure evaluation is allowed (`--impure`), the flake reference
-          must be "locked", e.g. contain a Git revision or content hash. An
-          example of an unlocked usage is:
-
-          ```nix
-          (builtins.getFlake "github:edolstra/dwarffs").rev
-          ```
-        )",
-        .fun = prim_getFlake,
-        .experimentalFeature = Xp::Flakes,
-    });
-}
-
 static void prim_parseFlakeRef(
     EvalState & state,
     const PosIdx pos,

src/libflake/flake/flake.hh

@@ -14,14 +14,6 @@ namespace flake {
 
 struct Settings;
 
-/**
- * Initialize `libnixflake`
- *
- * So far, this registers the `builtins.getFlake` primop, which depends
- * on the choice of `flake:Settings`.
- */
-void initLib(const Settings & settings);
-
 struct FlakeInput;
 
 typedef std::map<FlakeId, FlakeInput> FlakeInputs;

src/libflake/flake/settings.cc

@@ -1,7 +1,13 @@
 #include "flake/settings.hh"
+#include "flake/flake-primops.hh"
 
 namespace nix::flake {
 
 Settings::Settings() {}
 
+void Settings::configureEvalSettings(nix::EvalSettings & evalSettings)
+{
+    evalSettings.addPrimOp(primops::getFlake(*this));
 }
+
+} // namespace nix

src/libflake/flake/settings.hh

@@ -1,21 +1,24 @@
 #pragma once
 ///@file
 
-#include "types.hh"
 #include "config.hh"
-#include "util.hh"
-
-#include <map>
-#include <limits>
 
 #include <sys/types.h>
 
+namespace nix {
+// Forward declarations
+struct EvalSettings;
+
+} // namespace nix
+
 namespace nix::flake {
 
 struct Settings : public Config
 {
     Settings();
 
+    void configureEvalSettings(nix::EvalSettings & evalSettings);
+
     Setting<bool> useRegistries{
         this,
         true,

src/libflake/meson.build

@@ -44,6 +44,7 @@ sources = files(
   'flake/flake.cc',
   'flake/flakeref.cc',
   'flake/lockfile.cc',
+  'flake/flake-primops.cc',
   'flake/settings.cc',
   'flake/url-name.cc',
 )