use builtin_macros::builtins; use std::{ collections::BTreeMap, env, io, rc::{Rc, Weak}, time::{SystemTime, UNIX_EPOCH}, }; use crate::{ compiler::GlobalsMap, errors::ErrorKind, observer::NoOpObserver, spans::LightSpan, value::{Builtin, BuiltinArgument, NixAttrs, Thunk}, vm::VM, SourceCode, Value, }; #[builtins] mod impure_builtins { use super::*; use crate::builtins::coerce_value_to_path; #[builtin("getEnv")] fn builtin_get_env(_: &mut VM, var: Value) -> Result { Ok(env::var(var.to_str()?).unwrap_or_else(|_| "".into()).into()) } #[builtin("pathExists")] fn builtin_path_exists(vm: &mut VM, s: Value) -> Result { Ok(coerce_value_to_path(&s, vm)?.exists().into()) } #[builtin("readDir")] fn builtin_read_dir(vm: &mut VM, path: Value) -> Result { let path = coerce_value_to_path(&path, vm)?; let mk_err = |err: io::Error| ErrorKind::IO { path: Some(path.clone()), error: Rc::new(err), }; let res = path.read_dir().map_err(mk_err)?.into_iter().flat_map( |entry| -> Result<(String, &str), ErrorKind> { let entry = entry.map_err(mk_err)?; let file_type = entry .metadata() .map_err(|err| ErrorKind::IO { path: Some(entry.path()), error: Rc::new(err), })? .file_type(); let val = if file_type.is_dir() { "directory" } else if file_type.is_file() { "regular" } else if file_type.is_symlink() { "symlink" } else { "unknown" }; Ok((entry.file_name().to_string_lossy().to_string(), val)) }, ); Ok(Value::attrs(NixAttrs::from_iter(res))) } #[builtin("readFile")] fn builtin_read_file(vm: &mut VM, path: Value) -> Result { let path = coerce_value_to_path(&path, vm)?; vm.io() .read_to_string(path) .map(|s| Value::String(s.into())) } } /// Return all impure builtins, that is all builtins which may perform I/O /// outside of the VM and so cannot be used in all contexts (e.g. WASM). pub(super) fn builtins() -> BTreeMap<&'static str, Value> { let mut map: BTreeMap<&'static str, Value> = impure_builtins::builtins() .into_iter() .map(|b| (b.name(), Value::Builtin(b))) .collect(); // currentTime pins the time at which evaluation was started { let seconds = match SystemTime::now().duration_since(UNIX_EPOCH) { Ok(dur) => dur.as_secs() as i64, // This case is hit if the system time is *before* epoch. Err(err) => -(err.duration().as_secs() as i64), }; map.insert("currentTime", Value::Integer(seconds)); } map } /// Constructs and inserts the `import` builtin. This builtin is special in that /// it needs to capture the [crate::SourceCode] structure to correctly track /// source code locations while invoking a compiler. // TODO: need to be able to pass through a CompilationObserver, too. pub fn builtins_import(globals: &Weak, source: SourceCode) -> Builtin { // This (very cheap, once-per-compiler-startup) clone exists // solely in order to keep the borrow checker happy. It // resolves the tension between the requirements of // Rc::new_cyclic() and Builtin::new() let globals = globals.clone(); Builtin::new( "import", &[BuiltinArgument { strict: true, name: "path", }], None, move |mut args: Vec, vm: &mut VM| { let mut path = super::coerce_value_to_path(&args.pop().unwrap(), vm)?; if path.is_dir() { path.push("default.nix"); } let current_span = vm.current_span(); if let Some(cached) = vm.import_cache.get(&path) { return Ok(cached.clone()); } let contents = vm.io().read_to_string(path.clone())?; let parsed = rnix::ast::Root::parse(&contents); let errors = parsed.errors(); let file = source.add_file(path.to_string_lossy().to_string(), contents); if !errors.is_empty() { return Err(ErrorKind::ImportParseError { path, file, errors: errors.to_vec(), }); } let result = crate::compiler::compile( &parsed.tree().expr().unwrap(), Some(path.clone()), file, // The VM must ensure that a strong reference to the // globals outlives any self-references (which are // weak) embedded within the globals. If the // expect() below panics, it means that did not // happen. globals .upgrade() .expect("globals dropped while still in use"), &mut NoOpObserver::default(), ) .map_err(|err| ErrorKind::ImportCompilerError { path: path.clone(), errors: vec![err], })?; if !result.errors.is_empty() { return Err(ErrorKind::ImportCompilerError { path, errors: result.errors, }); } // Compilation succeeded, we can construct a thunk from whatever it spat // out and return that. let res = Value::Thunk(Thunk::new_suspended( result.lambda, LightSpan::new_actual(current_span), )); vm.import_cache.insert(path, res.clone()); for warning in result.warnings { vm.push_warning(warning); } Ok(res) }, ) }