nixir

#ifdef unix

#undef unix

#endif

#include "nix/expr/eval.hh"

#include "nix/expr/primops.hh"

#include "nix/expr/value.hh"

#include "irc/evaluator.h"

#include "irc/ir_gen.h"

#include "irc/parser.h"

#include "irc/serializer.h"

#include "irc/types.h"

#include <chrono>

#include <iostream>

namespace nix_ir_plugin {

using namespace nix;

using namespace nix_irc;

/**

 * Load and evaluate a pre-compiled IR bundle

 * Usage: builtins.nixIR.loadIR "/path/to/file.nixir"

 */

static void prim_loadIR(EvalState& state, const PosIdx pos, Value** args, Value& v) {

  auto path = state.forceStringNoCtx(

      *args[0], pos, "while evaluating the first argument to builtins.nixIR.loadIR");

  std::string pathStr(path);

  auto t_start = std::chrono::high_resolution_clock::now();

  Deserializer deserializer;

  IRModule module;

  try {

    module = deserializer.deserialize(pathStr);

  } catch (const std::exception& e) {

    state.error<EvalError>("failed to deserialize IR bundle: %s", e.what()).atPos(pos).debugThrow();

  }

  auto t_deser = std::chrono::high_resolution_clock::now();

  if (!module.entry) {

    state.error<EvalError>("IR bundle has no entry point").atPos(pos).debugThrow();

  }

  try {

    Evaluator evaluator(state);

    evaluator.eval_to_nix(module.entry, v);

  } catch (const std::exception& e) {

    state.error<EvalError>("failed to evaluate IR: %s", e.what()).atPos(pos).debugThrow();

  }

  auto t_eval = std::chrono::high_resolution_clock::now();

  auto deser_us = std::chrono::duration_cast<std::chrono::microseconds>(t_deser - t_start).count();

  auto eval_us = std::chrono::duration_cast<std::chrono::microseconds>(t_eval - t_deser).count();

  std::cerr << "nixIR timing: deser=" << deser_us << "us eval=" << eval_us

            << "us total=" << (deser_us + eval_us) << "us" << std::endl;

}

/**

 * Compile Nix source to IR on-the-fly

 * Usage: builtins.nixIR.compile "{ x = 1; }"

 */

static void prim_compileNix(EvalState& state, const PosIdx pos, Value** args, Value& v) {

  auto source = state.forceStringNoCtx(

      *args[0], pos, "while evaluating the first argument to builtins.nixIR.compile");

  std::string sourceStr(source);

  try {

    Parser parser;

    auto ast = parser.parse(sourceStr, "<inline>");

    if (!ast) {

      state.error<EvalError>("failed to parse Nix expression").atPos(pos).debugThrow();

    }

    IRGenerator ir_gen;

    auto ir = ir_gen.generate(ast);

    Evaluator evaluator(state);

    evaluator.eval_to_nix(ir, v);

  } catch (const std::exception& e) {

    state.error<EvalError>("IR compilation failed: %s", e.what()).atPos(pos).debugThrow();

  }

}

/**

 * Get information about the IR plugin

 * Usage: builtins.nixIR.info

 */

static void prim_info(EvalState& state, const PosIdx pos, Value** args, Value& v) {

  auto bindings = state.buildBindings(3);

  Value* vName = state.allocValue();

  vName->mkString("nix-ir-plugin");

  bindings.insert(state.symbols.create("name"), vName);

  Value* vVersion = state.allocValue();

  vVersion->mkString("0.1.0");

  bindings.insert(state.symbols.create("version"), vVersion);

  Value* vStatus = state.allocValue();

  vStatus->mkString("runtime-active");

  bindings.insert(state.symbols.create("status"), vStatus);

  v.mkAttrs(bindings.finish());

}

// Register primops on plugin load

static RegisterPrimOp rp_loadIR({

    .name = "__nixIR_loadIR",

    .args = {"path"},

    .arity = 1,

    .doc = R"(

      Load a pre-compiled IR bundle from the given path.

      Returns an attrset with information about the loaded bundle.

    )",

    .fun = prim_loadIR,

});

static RegisterPrimOp rp_compileNix({

    .name = "__nixIR_compile",

    .args = {"source"},

    .arity = 1,

    .doc = R"(

      Compile Nix source code to IR on-the-fly.

      Returns an attrset with information about the compiled IR.

    )",

    .fun = prim_compileNix,

});

static RegisterPrimOp rp_info({

    .name = "__nixIR_info",

    .args = {},

    .arity = 0,

    .doc = R"(

      Get information about the IR plugin.

      Returns an attrset with plugin name, version, and status.

    )",

    .fun = prim_info,

});

} // namespace nix_ir_plugin

// Plugin initialization

__attribute__((constructor)) static void init_plugin() {

  // Plugin loads silently...

}