From 273ba73754e9b10f768830d5a6835bf3d14e0d8a Mon Sep 17 00:00:00 2001 From: Griffin Smith Date: Sun, 9 Oct 2022 23:46:51 -0400 Subject: feat(tvix/eval): Initial resolution of `<...>` paths This commit implements (lazy) resolution of `<...>` paths via either the NIX_PATH environment variable, or the -I command-line flag - both handled via EvalOptions. As a result, EvalOptions can no longer derive Copy, meaning we have to clone it at each line of the repl - this is probably not a huge deal as repl performance is not exactly an inner loop and we're not cloning very much. Internally, this works by creating a thunk which pushes a constant containing the string inside the brackets to the stack, then a new opcode to resolve that path via the `NixPath`. To get that opcode to work, we now have to pass in the NixPath when constructing the VM. This (intentionally) leaves out proper implementation of path resolution via `findFile` (cppnix just calls whatever identifier called findFile is in scope!!!) as that's widely considered a bit of a misfeature, but if we do decide to implement that down the road it likely wouldn't be more than a few extra ops within the thunk introduced here. Change-Id: Ibc979b7e425b65cbe88599940520239a4a10cee2 Reviewed-on: https://cl.tvl.fyi/c/depot/+/6918 Autosubmit: grfn Reviewed-by: tazjin Tested-by: BuildkiteCI --- corp/tvixbolt/src/main.rs | 12 ++++++++++-- tvix/eval/src/compiler/mod.rs | 23 +++++++++++++++++------ tvix/eval/src/eval.rs | 19 ++++++++++++++++--- tvix/eval/src/main.rs | 2 +- tvix/eval/src/opcode.rs | 6 ++++++ tvix/eval/src/value/attrs/tests.rs | 6 +++--- tvix/eval/src/value/mod.rs | 8 ++++---- tvix/eval/src/value/string.rs | 7 +++++++ tvix/eval/src/vm.rs | 15 +++++++++++++-- 9 files changed, 77 insertions(+), 21 deletions(-) diff --git a/corp/tvixbolt/src/main.rs b/corp/tvixbolt/src/main.rs index 8099a5238d02..e6dda736f4a4 100644 --- a/corp/tvixbolt/src/main.rs +++ b/corp/tvixbolt/src/main.rs @@ -286,9 +286,17 @@ fn eval(trace: bool, code: &str) -> Output { } let result = if trace { - tvix_eval::run_lambda(&mut TracingObserver::new(&mut out.trace), result.lambda) + tvix_eval::run_lambda( + Default::default(), + &mut TracingObserver::new(&mut out.trace), + result.lambda, + ) } else { - tvix_eval::run_lambda(&mut NoOpObserver::default(), result.lambda) + tvix_eval::run_lambda( + Default::default(), + &mut NoOpObserver::default(), + result.lambda, + ) }; match result { diff --git a/tvix/eval/src/compiler/mod.rs b/tvix/eval/src/compiler/mod.rs index 941b945a8bb6..cfb0ee64a6d8 100644 --- a/tvix/eval/src/compiler/mod.rs +++ b/tvix/eval/src/compiler/mod.rs @@ -188,7 +188,7 @@ impl Compiler<'_> { fn compile(&mut self, slot: LocalIdx, expr: &ast::Expr) { match expr { ast::Expr::Literal(literal) => self.compile_literal(literal), - ast::Expr::Path(path) => self.compile_path(path), + ast::Expr::Path(path) => self.compile_path(slot, path), ast::Expr::Str(s) => self.compile_str(slot, s), ast::Expr::UnaryOp(op) => self.compile_unary_op(slot, op), @@ -249,7 +249,7 @@ impl Compiler<'_> { self.emit_constant(value, node); } - fn compile_path(&mut self, node: &ast::Path) { + fn compile_path(&mut self, slot: LocalIdx, node: &ast::Path) { // TODO(tazjin): placeholder implementation while waiting for // https://github.com/nix-community/rnix-parser/pull/96 @@ -274,13 +274,24 @@ impl Compiler<'_> { let mut buf = self.root_dir.clone(); buf.push(&raw_path); buf - } else { + } else if raw_path.starts_with('<') { // TODO: decide what to do with findFile + if raw_path.len() == 2 { + return self.emit_error( + node, + ErrorKind::PathResolution("Empty <> path not allowed".into()), + ); + } + let path = &raw_path[1..(raw_path.len() - 1)]; + // Make a thunk to resolve the path (without using `findFile`, at least for now?) + return self.thunk(slot, node, move |c, _| { + c.emit_constant(path.into(), node); + c.push_op(OpCode::OpFindFile, node); + }); + } else { self.emit_error( node, - ErrorKind::NotImplemented( - "other path types (e.g. <...> lookups) not yet implemented", - ), + ErrorKind::NotImplemented("other path types not yet implemented"), ); return; }; diff --git a/tvix/eval/src/eval.rs b/tvix/eval/src/eval.rs index e2495b69cdb0..809c8729f711 100644 --- a/tvix/eval/src/eval.rs +++ b/tvix/eval/src/eval.rs @@ -3,13 +3,14 @@ use std::{cell::RefCell, path::PathBuf, rc::Rc}; use crate::{ builtins::global_builtins, errors::{Error, ErrorKind, EvalResult}, + nix_path::NixPath, observer::{DisassemblingObserver, NoOpObserver, TracingObserver}, value::Value, SourceCode, }; /// Runtime options for the Tvix interpreter -#[derive(Debug, Clone, Copy, Default)] +#[derive(Debug, Clone, Default)] #[cfg_attr(feature = "repl", derive(clap::Parser))] pub struct Options { /// Dump the raw AST to stdout before interpreting @@ -23,6 +24,10 @@ pub struct Options { /// Trace the runtime of the VM #[cfg_attr(feature = "repl", clap(long, env = "TVIX_TRACE_RUNTIME"))] trace_runtime: bool, + + /// A colon-separated list of directories to use to resolve `<...>`-style paths + #[cfg_attr(feature = "repl", clap(long, short = 'I', env = "NIX_PATH"))] + nix_path: Option, } pub fn interpret(code: &str, location: Option, options: Options) -> EvalResult { @@ -105,9 +110,17 @@ pub fn interpret(code: &str, location: Option, options: Options) -> Eva } let result = if options.trace_runtime { - crate::vm::run_lambda(&mut TracingObserver::new(std::io::stderr()), result.lambda) + crate::vm::run_lambda( + options.nix_path.unwrap_or_default(), + &mut TracingObserver::new(std::io::stderr()), + result.lambda, + ) } else { - crate::vm::run_lambda(&mut NoOpObserver::default(), result.lambda) + crate::vm::run_lambda( + options.nix_path.unwrap_or_default(), + &mut NoOpObserver::default(), + result.lambda, + ) }; if let Err(err) = &result { diff --git a/tvix/eval/src/main.rs b/tvix/eval/src/main.rs index 0fbc7ad9a620..d70d82f68f8a 100644 --- a/tvix/eval/src/main.rs +++ b/tvix/eval/src/main.rs @@ -66,7 +66,7 @@ fn run_prompt(eval_options: tvix_eval::Options) { } rl.add_history_entry(&line); - match tvix_eval::interpret(&line, None, eval_options) { + match tvix_eval::interpret(&line, None, eval_options.clone()) { Ok(result) => { println!("=> {} :: {}", result, result.type_of()); } diff --git a/tvix/eval/src/opcode.rs b/tvix/eval/src/opcode.rs index 15f60a538c41..96234ccd233c 100644 --- a/tvix/eval/src/opcode.rs +++ b/tvix/eval/src/opcode.rs @@ -112,6 +112,12 @@ pub enum OpCode { /// `CoercionKind::Weak`. OpCoerceToString, + // Paths + /// Attempt to resolve the Value on the stack using the configured [`NixPath`][] + /// + /// [`NixPath`]: crate::nix_path::NixPath + OpFindFile, + // Type assertion operators OpAssertBool, diff --git a/tvix/eval/src/value/attrs/tests.rs b/tvix/eval/src/value/attrs/tests.rs index 4556d26dd00f..637114c89bc7 100644 --- a/tvix/eval/src/value/attrs/tests.rs +++ b/tvix/eval/src/value/attrs/tests.rs @@ -10,7 +10,7 @@ mod nix_eq { #[proptest(ProptestConfig { cases: 2, ..Default::default() })] fn reflexive(x: NixAttrs) { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); assert!(x.nix_eq(&x, &mut vm).unwrap()) } @@ -18,7 +18,7 @@ mod nix_eq { #[proptest(ProptestConfig { cases: 2, ..Default::default() })] fn symmetric(x: NixAttrs, y: NixAttrs) { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); assert_eq!( x.nix_eq(&y, &mut vm).unwrap(), @@ -29,7 +29,7 @@ mod nix_eq { #[proptest(ProptestConfig { cases: 2, ..Default::default() })] fn transitive(x: NixAttrs, y: NixAttrs, z: NixAttrs) { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); if x.nix_eq(&y, &mut vm).unwrap() && y.nix_eq(&z, &mut vm).unwrap() { assert!(x.nix_eq(&z, &mut vm).unwrap()) diff --git a/tvix/eval/src/value/mod.rs b/tvix/eval/src/value/mod.rs index 31ac0c07d4c2..fd5b5255c5d8 100644 --- a/tvix/eval/src/value/mod.rs +++ b/tvix/eval/src/value/mod.rs @@ -410,7 +410,7 @@ mod tests { #[proptest(ProptestConfig { cases: 5, ..Default::default() })] fn reflexive(x: Value) { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); assert!(x.nix_eq(&x, &mut vm).unwrap()) } @@ -418,7 +418,7 @@ mod tests { #[proptest(ProptestConfig { cases: 5, ..Default::default() })] fn symmetric(x: Value, y: Value) { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); assert_eq!( x.nix_eq(&y, &mut vm).unwrap(), @@ -429,7 +429,7 @@ mod tests { #[proptest(ProptestConfig { cases: 5, ..Default::default() })] fn transitive(x: Value, y: Value, z: Value) { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); if x.nix_eq(&y, &mut vm).unwrap() && y.nix_eq(&z, &mut vm).unwrap() { assert!(x.nix_eq(&z, &mut vm).unwrap()) @@ -439,7 +439,7 @@ mod tests { #[test] fn list_int_float_fungibility() { let mut observer = NoOpObserver {}; - let mut vm = VM::new(&mut observer); + let mut vm = VM::new(Default::default(), &mut observer); let v1 = Value::List(NixList::from(vec![Value::Integer(1)])); let v2 = Value::List(NixList::from(vec![Value::Float(1.0)])); diff --git a/tvix/eval/src/value/string.rs b/tvix/eval/src/value/string.rs index c21f2c4e8395..876b1abe6b40 100644 --- a/tvix/eval/src/value/string.rs +++ b/tvix/eval/src/value/string.rs @@ -3,6 +3,7 @@ use smol_str::SmolStr; use std::hash::Hash; use std::ops::Deref; +use std::path::Path; use std::{borrow::Cow, fmt::Display, str::Chars}; #[derive(Clone, Debug)] @@ -185,6 +186,12 @@ impl AsRef for NixString { } } +impl AsRef for NixString { + fn as_ref(&self) -> &Path { + self.as_str().as_ref() + } +} + impl Deref for NixString { type Target = str; diff --git a/tvix/eval/src/vm.rs b/tvix/eval/src/vm.rs index cf766fb33523..44ddda5a1f63 100644 --- a/tvix/eval/src/vm.rs +++ b/tvix/eval/src/vm.rs @@ -8,6 +8,7 @@ use path_clean::PathClean; use crate::{ chunk::Chunk, errors::{Error, ErrorKind, EvalResult}, + nix_path::NixPath, observer::RuntimeObserver, opcode::{CodeIdx, Count, JumpOffset, OpCode, StackIdx, UpvalueIdx}, upvalues::{UpvalueCarrier, Upvalues}, @@ -49,6 +50,8 @@ pub struct VM<'o> { /// Runtime warnings collected during evaluation. warnings: Vec, + nix_path: NixPath, + observer: &'o mut dyn RuntimeObserver, } @@ -139,8 +142,9 @@ macro_rules! cmp_op { } impl<'o> VM<'o> { - pub fn new(observer: &'o mut dyn RuntimeObserver) -> Self { + pub fn new(nix_path: NixPath, observer: &'o mut dyn RuntimeObserver) -> Self { Self { + nix_path, observer, frames: vec![], stack: vec![], @@ -477,6 +481,12 @@ impl<'o> VM<'o> { self.push(Value::String(string)); } + OpCode::OpFindFile => { + let path = self.pop().to_str().map_err(|e| self.error(e))?; + let resolved = self.nix_path.resolve(path).map_err(|e| self.error(e))?; + self.push(resolved.into()); + } + OpCode::OpJump(JumpOffset(offset)) => { debug_assert!(offset != 0); self.frame_mut().ip += offset; @@ -838,10 +848,11 @@ fn unwrap_or_clone_rc(rc: Rc) -> T { } pub fn run_lambda( + nix_path: NixPath, observer: &mut dyn RuntimeObserver, lambda: Rc, ) -> EvalResult { - let mut vm = VM::new(observer); + let mut vm = VM::new(nix_path, observer); let value = vm.call(lambda, Upvalues::with_capacity(0), 0)?; vm.force_for_output(&value)?; -- cgit 1.4.1