feat(tvix/eval): Initial resolution of `<...>` paths r/5087

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 <grfn@gws.fyi>
Reviewed-by: tazjin <tazjin@tvl.su>
Tested-by: BuildkiteCI

8 files changed, 67 insertions, 19 deletions

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<NixPath>,
 }
 
 pub fn interpret(code: &str, location: Option<PathBuf>, options: Options) -> EvalResult<Value> {
@@ -105,9 +110,17 @@ pub fn interpret(code: &str, location: Option<PathBuf>, 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<str> for NixString {
     }
 }
 
+impl AsRef<Path> 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<EvalWarning>,
 
+    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<T: Clone>(rc: Rc<T>) -> T {
 }
 
 pub fn run_lambda(
+    nix_path: NixPath,
     observer: &mut dyn RuntimeObserver,
     lambda: Rc<Lambda>,
 ) -> EvalResult<RuntimeResult> {
-    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)?;