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

1 files changed, 13 insertions, 2 deletions

diff --git a/tvix/eval/src/vm.rs b/tvix/eval/src/vm.rs
index cf766fb335..44ddda5a1f 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)?;