fix compilation with nix 2.24

flake.nix

@@ -33,7 +33,7 @@
             callPackage
             stdenv
             ;
-          nix = nixVersions.nix_2_19;
+          nix = nixVersions.nix_2_24;
           llvmPackages = llvmPackages_16;
           nixf = callPackage ./libnixf { };
           nixt = callPackage ./libnixt { inherit nix; };

libnixt/include/nixt/InitEval.h

@@ -3,12 +3,18 @@
 #include <nix/eval.hh>
 #include <nix/shared.hh>
 #include <nix/store-api.hh>
+#include <nix/eval-gc.hh>
+#include <nix/eval-settings.hh>
+#include <nix/flake/flake.hh>
+#include <nix/plugin.hh>
+#include <nix/common-eval-args.hh>
 
 namespace nixt {
 
 inline void initEval() {
   nix::initNix();
   nix::initLibStore();
+  nix::flake::initLib(nix::flakeSettings);
   nix::initPlugins();
   nix::initGC();
 }

libnixt/lib/Flake.cpp

@@ -147,12 +147,12 @@ void nixt::callDirtyFlake(EvalState &State, std::string_view Src,
                           nix::Value &VRes) {
 
   nix::Value *VSrc = State.allocValue();
-  VSrc->mkPath(State.rootPath(nix::CanonPath(Src, nix::CanonPath::fromCwd())));
+  VSrc->mkPath(State.rootPath(nix::CanonPath(Src)));
 
   auto *VFlakeCompat = State.allocValue();
 
   nix::Expr *EFlakeCompat = State.parseExprFromString(
-      FlakeCompat, State.rootPath(nix::CanonPath::fromCwd()));
+      FlakeCompat, State.rootPath("."));
   State.eval(EFlakeCompat, *VFlakeCompat);
 
   State.callFunction(*VFlakeCompat, *VSrc, VRes, noPos);

libnixt/lib/Value.cpp

@@ -14,7 +14,7 @@ std::optional<nix::Value> nixt::getField(nix::EvalState &State, nix::Value &V,
     return std::nullopt;
 
   nix::Symbol SFiled = State.symbols.create(Field);
-  if (auto *It = V.attrs->find(SFiled); It != V.attrs->end())
+  if (auto *It = V.attrs()->find(SFiled); It != V.attrs()->end())
     return *It->value;
 
   return std::nullopt;
@@ -86,11 +86,11 @@ nix::Value &nixt::selectAttr(nix::EvalState &State, nix::Value &V,
   State.forceValue(V, nix::noPos);
 
   if (V.type() != nix::ValueType::nAttrs)
-    throw nix::TypeError("value is not an attrset");
+    throw nix::TypeError(State, "value is not an attrset");
 
-  assert(V.attrs && "nix must allocate non-null attrs!");
-  auto *Nested = V.attrs->find(Attr);
-  if (Nested == V.attrs->end())
+  assert(V.attrs() && "nix must allocate non-null attrs!");
+  auto *Nested = V.attrs()->find(Attr);
+  if (Nested == V.attrs()->end())
     throw nix::AttrPathNotFound("attrname " + State.symbols[Attr] +
                                 " not found in attrset");
 
@@ -145,11 +145,12 @@ nix::Value getSubOptions(nix::EvalState &State, nix::Value &Type) {
   nix::Value &GetSubOptions =
       selectAttr(State, Type, State.symbols.create("getSubOptions"));
 
-  nix::Value EmptyList;
-  EmptyList.mkList(0);
+  auto list = State.buildList(0);
+  auto EmptyList = State.allocValue();
+  EmptyList->mkList(list);
   // Invoke "GetSubOptions"
   nix::Value VResult;
-  State.callFunction(GetSubOptions, EmptyList, VResult, nix::noPos);
+  State.callFunction(GetSubOptions, *EmptyList, VResult, nix::noPos);
   return VResult;
 }
 

libnixt/test/StateTest.h

@@ -2,12 +2,13 @@
 
 #include <nix/eval.hh>
 #include <nix/store-api.hh>
+#include <nix/common-eval-args.hh>
 
 namespace nixt {
 
 struct StateTest : testing::Test {
   std::unique_ptr<nix::EvalState> State;
-  StateTest() : State(new nix::EvalState{{}, nix::openStore("dummy://")}) {}
+  StateTest() : State(new nix::EvalState{{}, nix::openStore("dummy://"), nix::fetchSettings, nix::evalSettings}) {}
 };
 
 } // namespace nixt

libnixt/test/Value.cpp

@@ -7,7 +7,7 @@ using namespace nixt;
 namespace {
 
 struct ValueTest : StateTest {
-  nix::SourcePath cwd() { return State->rootPath(nix::CanonPath::fromCwd()); }
+  nix::SourcePath cwd() { return State->rootPath("."); }
 };
 
 TEST_F(ValueTest, IsOption_neg) {

nixd/lib/Eval/AttrSetProvider.cpp

@@ -6,6 +6,7 @@
 #include <nix/attr-path.hh>
 #include <nix/nixexpr.hh>
 #include <nix/store-api.hh>
+#include <nix/common-eval-args.hh>
 #include <nixt/Value.h>
 
 using namespace nixd;
@@ -22,7 +23,7 @@ void fillString(nix::EvalState &State, nix::Value &V,
     nix::Value &Select = nixt::selectStringViews(State, V, AttrPath);
     State.forceValue(Select, nix::noPos);
     if (Select.type() == nix::ValueType::nString)
-      Field = Select.string.c_str;
+      Field = Select.string_view();
   } catch (std::exception &E) {
     Field = std::nullopt;
   }
@@ -131,16 +132,16 @@ void fillOptionDescription(nix::EvalState &State, nix::Value &V,
   fillOptionDeclarations(State, V, R);
   // FIXME: add definitions location.
   if (V.type() == nix::ValueType::nAttrs) [[likely]] {
-    assert(V.attrs);
-    if (auto *It = V.attrs->find(State.symbols.create("type"));
-        It != V.attrs->end()) [[likely]] {
+    assert(V.attrs());
+    if (auto *It = V.attrs()->find(State.symbols.create("type"));
+        It != V.attrs()->end()) [[likely]] {
       OptionType Type;
       fillOptionType(State, *It->value, Type);
       R.Type = std::move(Type);
     }
 
-    if (auto *It = V.attrs->find(State.symbols.create("example"));
-        It != V.attrs->end()) {
+    if (auto *It = V.attrs()->find(State.symbols.create("example"));
+        It != V.attrs()->end()) {
       State.forceValue(*It->value, It->pos);
 
       // In nixpkgs some examples are nested in "literalExpression"
@@ -157,10 +158,12 @@ void fillOptionDescription(nix::EvalState &State, nix::Value &V,
 
 } // namespace
 
+//  myArgs.lookupPath, evalStore, fetchSettings,
+//  evalSettings);
 AttrSetProvider::AttrSetProvider(std::unique_ptr<InboundPort> In,
                                  std::unique_ptr<OutboundPort> Out)
     : LSPServer(std::move(In), std::move(Out)),
-      State(new nix::EvalState({}, nix::openStore())) {
+      State(new nix::EvalState({}, nix::openStore(), nix::fetchSettings, nix::evalSettings)) {
   Registry.addMethod(rpcMethod::EvalExpr, this, &AttrSetProvider::onEvalExpr);
   Registry.addMethod(rpcMethod::AttrPathInfo, this,
                      &AttrSetProvider::onAttrPathInfo);
@@ -177,7 +180,7 @@ void AttrSetProvider::onEvalExpr(
     lspserver::Callback<std::optional<std::string>> Reply) {
   try {
     nix::Expr *AST = state().parseExprFromString(
-        Name, state().rootPath(nix::CanonPath::fromCwd()));
+        Name, state().rootPath("."));
     state().eval(AST, Nixpkgs);
     Reply(std::nullopt);
     return;
@@ -234,9 +237,9 @@ void AttrSetProvider::onAttrPathComplete(
     // evaluating package details.
     // "Trie"s may not beneficial becausae it cannot speedup eval.
     for (const auto *AttrPtr :
-         Scope.attrs->lexicographicOrder(state().symbols)) {
+         Scope.attrs()->lexicographicOrder(state().symbols)) {
       const nix::Attr &Attr = *AttrPtr;
-      const std::string Name = state().symbols[Attr.name];
+      const std::string_view Name = state().symbols[Attr.name];
       if (Name.starts_with(Params.Prefix)) {
         ++Num;
         Names.emplace_back(Name);
@@ -309,9 +312,9 @@ void AttrSetProvider::onOptionComplete(
     // evaluating package details.
     // "Trie"s may not beneficial becausae it cannot speedup eval.
     for (const auto *AttrPtr :
-         Scope.attrs->lexicographicOrder(state().symbols)) {
+         Scope.attrs()->lexicographicOrder(state().symbols)) {
       const nix::Attr &Attr = *AttrPtr;
-      std::string Name = state().symbols[Attr.name];
+      std::string_view Name = state().symbols[Attr.name];
       if (Name.starts_with(Params.Prefix)) {
         // Add a new "OptionField", see it's type.
         assert(Attr.value);