add %eval_nix% primop

Cargo.toml

@@ -45,6 +45,8 @@ codespan-reporting = "0.11"
 comrak = "0.17.0"
 criterion = "0.4"
 csv = "1"
+cxx = "1.0"
+cxx-build = "1.0"
 derive_more = "0.99"
 directories = "4.0.1"
 env_logger = "0.10"
@@ -65,6 +67,7 @@ malachite-q = "0.3.2"
 md-5 = "0.10.5"
 once_cell = "1.17.1"
 pprof = "0.11.1"
+pkg-config = "0.3.27"
 pretty = "0.11.3"
 pretty_assertions = "1.3.0"
 pyo3 = "0.17.3"

core/Cargo.toml

@@ -9,6 +9,11 @@ keywords.workspace = true
 license.workspace = true
 repository.workspace = true
 readme.workspace = true
+# Maybe we should have the nix bindings in a separate -sys crate. maybe we
+# should even have separate crates for "nix-store", "nix-cmd", "nix-expr", "nix-
+# main", since they're separate libraries, but that seems a bit over the top.
+# SEE: https://kornel.ski/rust-sys-crate
+links = "nix"
 
 [lib]
 bench = false
@@ -21,9 +26,12 @@ repl-wasm = ["dep:wasm-bindgen", "dep:js-sys", "dep:serde_repr"]
 doc = ["dep:comrak"]
 format = ["dep:topiary", "dep:topiary-queries", "dep:tree-sitter-nickel"]
 metrics = ["dep:metrics"]
+nix-experimental = [ "dep:cxx", "dep:cxx-build", "dep:pkg-config" ]
 
 [build-dependencies]
 lalrpop.workspace = true
+cxx-build = { workspace = true, optional = true }
+pkg-config = { workspace = true, optional = true }
 
 [dependencies]
 lalrpop-util.workspace = true
@@ -32,6 +40,7 @@ simple-counter.workspace = true
 clap = { workspace = true, features = ["derive"] }
 codespan.workspace = true
 codespan-reporting.workspace = true
+cxx = { workspace = true, optional = true }
 logos.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true

core/build.rs

@@ -3,4 +3,29 @@ fn main() {
         .use_cargo_dir_conventions()
         .process_file("src/parser/grammar.lalrpop")
         .unwrap();
+
+    #[cfg(feature = "nix-experimental")]
+    {
+        use cxx_build::CFG;
+        use std::path::PathBuf;
+
+        for lib in &["nix-store", "nix-cmd", "nix-expr", "nix-main"] {
+            let lib = pkg_config::Config::new()
+                .atleast_version("2.16.0")
+                .probe(lib)
+                .unwrap();
+            let lib_include_paths = lib.include_paths.iter().map(PathBuf::as_path);
+            CFG.exported_header_dirs.extend(lib_include_paths);
+        }
+
+        cxx_build::bridge("src/nix_ffi/mod.rs")
+            .file("src/nix_ffi/cpp/nix.cc")
+            .flag_if_supported("-std=c++20")
+            .flag_if_supported("-U_FORTIFY_SOURCE") // Otherwise builds with `-O0` raise a lot of warnings
+            .compile("nickel-lang");
+
+        println!("cargo:rerun-if-changed=src/nix_ffi/mod.rs");
+        println!("cargo:rerun-if-changed=src/nix_ffi/cpp/nix.cc");
+        println!("cargo:rerun-if-changed=src/nix_ffi/cpp/nix.hh");
+    }
 }

core/src/cache.rs

@@ -3,6 +3,8 @@
 use crate::error::{Error, ImportError, ParseError, ParseErrors, TypecheckError};
 use crate::eval::cache::Cache as EvalCache;
 use crate::eval::Closure;
+#[cfg(feature = "nix-experimental")]
+use crate::nix_ffi;
 use crate::parser::{lexer::Lexer, ErrorTolerantParser};
 use crate::position::TermPos;
 use crate::stdlib::{self as nickel_stdlib, StdlibModule};
@@ -28,12 +30,15 @@ use std::time::SystemTime;
 use void::Void;
 
 /// Supported input formats.
-#[derive(Clone, Copy, Eq, Debug, PartialEq)]
+#[derive(Default, Clone, Copy, Eq, Debug, PartialEq)]
 pub enum InputFormat {
+    #[default]
     Nickel,
     Json,
     Yaml,
     Toml,
+    #[cfg(feature = "nix-experimental")]
+    Nix,
 }
 
 impl InputFormat {
@@ -44,6 +49,8 @@ impl InputFormat {
             Some("json") => Some(InputFormat::Json),
             Some("yaml") | Some("yml") => Some(InputFormat::Yaml),
             Some("toml") => Some(InputFormat::Toml),
+            #[cfg(feature = "nix-experimental")]
+            Some("nix") => Some(InputFormat::Nix),
             _ => None,
         }
     }
@@ -520,7 +527,7 @@ impl Cache {
 
     /// Parse a source without querying nor populating the cache.
     pub fn parse_nocache(&self, file_id: FileId) -> Result<(RichTerm, ParseErrors), ParseError> {
-        self.parse_nocache_multi(file_id, InputFormat::Nickel)
+        self.parse_nocache_multi(file_id, InputFormat::default())
     }
 
     /// Parse a source without querying nor populating the cache. Support multiple formats.
@@ -588,6 +595,14 @@ impl Cache {
             InputFormat::Toml => toml::from_str(self.files.source(file_id))
                 .map(|t| (attach_pos(t), ParseErrors::default()))
                 .map_err(|err| (ParseError::from_toml(err, file_id))),
+            #[cfg(feature = "nix-experimental")]
+            InputFormat::Nix => {
+                let json = nix_ffi::eval_to_json(self.files.source(file_id))
+                    .map_err(|e| ParseError::from_nix(e.what(), file_id))?;
+                serde_json::from_str(&json)
+                    .map(|t| (attach_pos(t), ParseErrors::default()))
+                    .map_err(|err| ParseError::from_serde_json(err, file_id, &self.files))
+            }
         }
     }
 
@@ -1297,7 +1312,7 @@ impl ImportResolver for Cache {
     ) -> Result<(ResolvedTerm, FileId), ImportError> {
         let parent_path = parent.and_then(|p| self.get_path(p)).map(PathBuf::from);
         let path_buf = with_parent(path, parent_path);
-        let format = InputFormat::from_path(&path_buf).unwrap_or(InputFormat::Nickel);
+        let format = InputFormat::from_path(&path_buf).unwrap_or_default();
         let id_op = self.get_or_add_file(&path_buf).map_err(|err| {
             ImportError::IOError(
                 path_buf.to_string_lossy().into_owned(),

core/src/error.rs

@@ -499,6 +499,8 @@ pub enum ParseError {
         /// The previous instance of the duplicated identifier.
         prev_ident: LocIdent,
     },
+    /// There was an attempt to use a feature that hasn't been enabled
+    DisabledFeature { feature: String, span: RawSpan },
 }
 
 /// An error occurring during the resolution of an import.
@@ -699,6 +701,9 @@ impl ParseError {
                 InternalParseError::DuplicateIdentInRecordPattern { ident, prev_ident } => {
                     ParseError::DuplicateIdentInRecordPattern { ident, prev_ident }
                 }
+                InternalParseError::DisabledFeature { feature, span } => {
+                    ParseError::DisabledFeature { feature, span }
+                }
             },
         }
     }
@@ -764,6 +769,12 @@ impl ParseError {
             }),
         )
     }
+
+    #[cfg(feature = "nix-experimental")]
+    pub fn from_nix(error: &str, _file_id: FileId) -> Self {
+        // Span is shown in the nix error message
+        ParseError::ExternalFormatError(String::from("nix"), error.to_string(), None)
+    }
 }
 
 pub const INTERNAL_ERROR_MSG: &str =
@@ -1785,6 +1796,16 @@ impl IntoDiagnostics<FileId> for ParseError {
                     secondary(&prev_ident.pos.unwrap()).with_message("previous binding here"),
                     primary(&ident.pos.unwrap()).with_message("duplicated binding here"),
                 ]),
+            ParseError::DisabledFeature { feature, span } => Diagnostic::error()
+                .with_message("interpreter compiled without required features")
+                .with_labels(vec![primary(&span).with_message(format!(
+                    "this syntax is only supported with the `{}` feature enabled",
+                    feature
+                ))])
+                .with_notes(vec![format!(
+                    "Recompile nickel with `--features {}`",
+                    feature
+                )]),
         };
 
         vec![diagnostic]

core/src/eval/operation.rs

@@ -12,6 +12,9 @@ use super::{
     subst, Cache, Closure, Environment, ImportResolver, VirtualMachine,
 };
 
+#[cfg(feature = "nix-experimental")]
+use crate::nix_ffi;
+
 use crate::{
     error::{EvalError, IllegalPolymorphicTailAction},
     identifier::LocIdent,
@@ -1155,6 +1158,30 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                     Err(mk_type_error!("label_push_diag", "Label"))
                 }}
             }
+            #[cfg(feature = "nix-experimental")]
+            UnaryOp::EvalNix() => {
+                if let Term::Str(s) = &*t {
+                    let json = nix_ffi::eval_to_json(&String::from(s)).map_err(|e| {
+                        EvalError::Other(
+                            format!("nix code failed to evaluate:\n {}", e.what()),
+                            pos,
+                        )
+                    })?;
+                    Ok(Closure::atomic_closure(
+                        serde_json::from_str(&json).map_err(|e| {
+                            EvalError::Other(format!("Nix produced invalid json: {}", e), pos)
+                        })?,
+                    ))
+                } else {
+                    // Not using mk_type_error! because of a non-uniform message
+                    Err(EvalError::TypeError(
+                        String::from("String"),
+                        String::from("eval_nix takes a string of nix code as an argument"),
+                        arg_pos,
+                        RichTerm { term: t, pos },
+                    ))
+                }
+            }
         }
     }
 

core/src/lib.rs

@@ -7,6 +7,8 @@ pub mod error;
 pub mod eval;
 pub mod identifier;
 pub mod label;
+#[cfg(feature = "nix-experimental")]
+pub mod nix_ffi;
 pub mod parser;
 pub mod position;
 pub mod pretty;

core/src/nix_ffi/cpp/nix.cc

@@ -0,0 +1,47 @@
+#include "nix.hh"
+
+using namespace nix;
+
+#include <nix/config.h>
+#include <nix/store-api.hh>
+#include <nix/eval.hh>
+#include <nix/shared.hh>
+#include <nix/canon-path.hh>
+#include <nix/nixexpr.hh>
+#include <nix/value-to-json.hh>
+#include <nix/command.hh>
+#include <nix/value.hh>
+
+#include "nickel-lang-core/src/nix_ffi/mod.rs.h"
+
+// nix is designed with command-line use in mind, and there's some setup stuff
+// that's tied to the EvalCommand class.
+struct DummyEvalCommand : virtual EvalCommand {
+
+  void run(ref<Store> store) override
+  {
+    // so it doesn't complain about unused variables
+    (void)store;
+  }
+
+};
+
+// FIXME: error messages have an extra `error:` on them
+rust::String eval_to_json(rust::Str nixCode)
+{
+  auto dummy = DummyEvalCommand({});
+  initNix();
+  initGC();
+  auto & state = *dummy.getEvalState();
+
+  auto vRes = state.allocValue();
+  state.eval(state.parseExprFromString(std::string(nixCode), state.rootPath(CanonPath::root)), *vRes);
+
+  std::stringstream out;
+  NixStringContext context;
+  // TODO: don't force the value. figure out a way to return thunks.
+  //       (second argument)
+  printValueAsJSON(state, true, *vRes, noPos, out, context, false);
+
+  return out.str();
+}