about summary refs log tree commit diff
path: root/tvix/eval
diff options
context:
space:
mode:
Diffstat (limited to 'tvix/eval')
-rw-r--r--tvix/eval/src/eval.rs8
-rw-r--r--tvix/eval/src/lib.rs2
-rw-r--r--tvix/eval/src/nix_search_path.rs (renamed from tvix/eval/src/nix_path.rs)64
-rw-r--r--tvix/eval/src/opcode.rs4
-rw-r--r--tvix/eval/src/vm.rs17
5 files changed, 49 insertions, 46 deletions
diff --git a/tvix/eval/src/eval.rs b/tvix/eval/src/eval.rs
index 809c8729f711..8973c1a95c19 100644
--- a/tvix/eval/src/eval.rs
+++ b/tvix/eval/src/eval.rs
@@ -3,7 +3,7 @@ use std::{cell::RefCell, path::PathBuf, rc::Rc};
 use crate::{
     builtins::global_builtins,
     errors::{Error, ErrorKind, EvalResult},
-    nix_path::NixPath,
+    nix_search_path::NixSearchPath,
     observer::{DisassemblingObserver, NoOpObserver, TracingObserver},
     value::Value,
     SourceCode,
@@ -27,7 +27,7 @@ pub struct Options {
 
     /// 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>,
+    nix_search_path: Option<NixSearchPath>,
 }
 
 pub fn interpret(code: &str, location: Option<PathBuf>, options: Options) -> EvalResult<Value> {
@@ -111,13 +111,13 @@ pub fn interpret(code: &str, location: Option<PathBuf>, options: Options) -> Eva
 
     let result = if options.trace_runtime {
         crate::vm::run_lambda(
-            options.nix_path.unwrap_or_default(),
+            options.nix_search_path.unwrap_or_default(),
             &mut TracingObserver::new(std::io::stderr()),
             result.lambda,
         )
     } else {
         crate::vm::run_lambda(
-            options.nix_path.unwrap_or_default(),
+            options.nix_search_path.unwrap_or_default(),
             &mut NoOpObserver::default(),
             result.lambda,
         )
diff --git a/tvix/eval/src/lib.rs b/tvix/eval/src/lib.rs
index 3c4fe26cd478..a7505eaf3acc 100644
--- a/tvix/eval/src/lib.rs
+++ b/tvix/eval/src/lib.rs
@@ -12,7 +12,7 @@ mod value;
 mod vm;
 mod warnings;
 
-mod nix_path;
+mod nix_search_path;
 #[cfg(test)]
 mod properties;
 #[cfg(test)]
diff --git a/tvix/eval/src/nix_path.rs b/tvix/eval/src/nix_search_path.rs
index 61e45c66d065..82a2a950998b 100644
--- a/tvix/eval/src/nix_path.rs
+++ b/tvix/eval/src/nix_search_path.rs
@@ -6,11 +6,11 @@ use std::str::FromStr;
 use crate::errors::ErrorKind;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-enum NixPathEntry {
+enum NixSearchPathEntry {
     /// Resolve subdirectories of this path within `<...>` brackets. This
     /// corresponds to bare paths within the `NIX_PATH` environment variable
     ///
-    /// For example, with `NixPathEntry::Path("/example")` and the following
+    /// For example, with `NixSearchPathEntry::Path("/example")` and the following
     /// directory structure:
     ///
     /// ```notrust
@@ -27,7 +27,7 @@ enum NixPathEntry {
     /// Resolve paths starting with `prefix` as subdirectories of `path`. This
     /// corresponds to `prefix=path` within the `NIX_PATH` environment variable.
     ///
-    /// For example, with `NixPathEntry::Prefix { prefix: "prefix", path:
+    /// For example, with `NixSearchPathEntry::Prefix { prefix: "prefix", path:
     /// "/example" }` and the following directory structure:
     ///
     /// ```notrust
@@ -42,7 +42,7 @@ enum NixPathEntry {
     Prefix { prefix: PathBuf, path: PathBuf },
 }
 
-impl NixPathEntry {
+impl NixSearchPathEntry {
     fn resolve(&self, lookup_path: &Path) -> io::Result<Option<PathBuf>> {
         let resolve_in =
             |parent: &Path, lookup_path: &Path| match parent.join(lookup_path).canonicalize() {
@@ -52,8 +52,8 @@ impl NixPathEntry {
             };
 
         match self {
-            NixPathEntry::Path(p) => resolve_in(p, lookup_path),
-            NixPathEntry::Prefix { prefix, path } => {
+            NixSearchPathEntry::Path(p) => resolve_in(p, lookup_path),
+            NixSearchPathEntry::Prefix { prefix, path } => {
                 if let Ok(child_path) = lookup_path.strip_prefix(prefix) {
                     resolve_in(path, child_path)
                 } else {
@@ -64,7 +64,7 @@ impl NixPathEntry {
     }
 }
 
-impl FromStr for NixPathEntry {
+impl FromStr for NixSearchPathEntry {
     type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -83,14 +83,14 @@ impl FromStr for NixPathEntry {
 ///
 /// This struct can be constructed by parsing a string using the [`FromStr`]
 /// impl, or via [`str::parse`]. Nix `<...>` paths can then be resolved using
-/// [`NixPath::resolve`].
+/// [`NixSearchPath::resolve`].
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct NixPath {
-    entries: Vec<NixPathEntry>,
+pub struct NixSearchPath {
+    entries: Vec<NixSearchPathEntry>,
 }
 
-impl NixPath {
-    /// Attempt to resolve the given `path` within this [`NixPath`] using the
+impl NixSearchPath {
+    /// Attempt to resolve the given `path` within this [`NixSearchPath`] using the
     /// path resolution rules for `<...>`-style paths
     #[allow(dead_code)] // TODO(grfn)
     pub fn resolve<P>(&self, path: P) -> Result<PathBuf, ErrorKind>
@@ -110,7 +110,7 @@ impl NixPath {
     }
 }
 
-impl FromStr for NixPath {
+impl FromStr for NixSearchPath {
     type Err = Infallible;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -118,7 +118,7 @@ impl FromStr for NixPath {
             .split(':')
             .map(|s| s.parse())
             .collect::<Result<Vec<_>, _>>()?;
-        Ok(NixPath { entries })
+        Ok(NixSearchPath { entries })
     }
 }
 
@@ -132,11 +132,11 @@ mod tests {
         #[test]
         fn bare_paths() {
             assert_eq!(
-                NixPath::from_str("/foo/bar:/baz").unwrap(),
-                NixPath {
+                NixSearchPath::from_str("/foo/bar:/baz").unwrap(),
+                NixSearchPath {
                     entries: vec![
-                        NixPathEntry::Path("/foo/bar".into()),
-                        NixPathEntry::Path("/baz".into())
+                        NixSearchPathEntry::Path("/foo/bar".into()),
+                        NixSearchPathEntry::Path("/baz".into())
                     ],
                 }
             );
@@ -145,14 +145,14 @@ mod tests {
         #[test]
         fn mixed_prefix_and_paths() {
             assert_eq!(
-                NixPath::from_str("nixpkgs=/my/nixpkgs:/etc/nixos").unwrap(),
-                NixPath {
+                NixSearchPath::from_str("nixpkgs=/my/nixpkgs:/etc/nixos").unwrap(),
+                NixSearchPath {
                     entries: vec![
-                        NixPathEntry::Prefix {
+                        NixSearchPathEntry::Prefix {
                             prefix: "nixpkgs".into(),
                             path: "/my/nixpkgs".into()
                         },
-                        NixPathEntry::Path("/etc/nixos".into())
+                        NixSearchPathEntry::Path("/etc/nixos".into())
                     ],
                 }
             );
@@ -168,15 +168,15 @@ mod tests {
 
         #[test]
         fn simple_dir() {
-            let nix_path = NixPath::from_str("./.").unwrap();
-            let res = nix_path.resolve("src").unwrap();
+            let nix_search_path = NixSearchPath::from_str("./.").unwrap();
+            let res = nix_search_path.resolve("src").unwrap();
             assert_eq!(res, current_dir().unwrap().join("src").clean());
         }
 
         #[test]
         fn failed_resolution() {
-            let nix_path = NixPath::from_str("./.").unwrap();
-            let err = nix_path.resolve("nope").unwrap_err();
+            let nix_search_path = NixSearchPath::from_str("./.").unwrap();
+            let err = nix_search_path.resolve("nope").unwrap_err();
             assert!(
                 matches!(err, ErrorKind::PathResolution(..)),
                 "err = {err:?}"
@@ -185,22 +185,22 @@ mod tests {
 
         #[test]
         fn second_in_path() {
-            let nix_path = NixPath::from_str("./.:/").unwrap();
-            let res = nix_path.resolve("bin").unwrap();
+            let nix_search_path = NixSearchPath::from_str("./.:/").unwrap();
+            let res = nix_search_path.resolve("bin").unwrap();
             assert_eq!(res, Path::new("/bin"));
         }
 
         #[test]
         fn prefix() {
-            let nix_path = NixPath::from_str("/:tvix=.").unwrap();
-            let res = nix_path.resolve("tvix/src").unwrap();
+            let nix_search_path = NixSearchPath::from_str("/:tvix=.").unwrap();
+            let res = nix_search_path.resolve("tvix/src").unwrap();
             assert_eq!(res, current_dir().unwrap().join("src").clean());
         }
 
         #[test]
         fn matching_prefix() {
-            let nix_path = NixPath::from_str("/:tvix=.").unwrap();
-            let res = nix_path.resolve("tvix").unwrap();
+            let nix_search_path = NixSearchPath::from_str("/:tvix=.").unwrap();
+            let res = nix_search_path.resolve("tvix").unwrap();
             assert_eq!(res, current_dir().unwrap().clean());
         }
     }
diff --git a/tvix/eval/src/opcode.rs b/tvix/eval/src/opcode.rs
index 96234ccd233c..c44494d57aa9 100644
--- a/tvix/eval/src/opcode.rs
+++ b/tvix/eval/src/opcode.rs
@@ -113,9 +113,9 @@ pub enum OpCode {
     OpCoerceToString,
 
     // Paths
-    /// Attempt to resolve the Value on the stack using the configured [`NixPath`][]
+    /// Attempt to resolve the Value on the stack using the configured [`NixSearchPath`][]
     ///
-    /// [`NixPath`]: crate::nix_path::NixPath
+    /// [`NixSearchPath`]: crate::nix_search_path::NixSearchPath
     OpFindFile,
 
     // Type assertion operators
diff --git a/tvix/eval/src/vm.rs b/tvix/eval/src/vm.rs
index ebf3de297b5a..c54c005b0041 100644
--- a/tvix/eval/src/vm.rs
+++ b/tvix/eval/src/vm.rs
@@ -8,7 +8,7 @@ use path_clean::PathClean;
 use crate::{
     chunk::Chunk,
     errors::{Error, ErrorKind, EvalResult},
-    nix_path::NixPath,
+    nix_search_path::NixSearchPath,
     observer::RuntimeObserver,
     opcode::{CodeIdx, Count, JumpOffset, OpCode, StackIdx, UpvalueIdx},
     upvalues::{UpvalueCarrier, Upvalues},
@@ -50,7 +50,7 @@ pub struct VM<'o> {
     /// Runtime warnings collected during evaluation.
     warnings: Vec<EvalWarning>,
 
-    nix_path: NixPath,
+    nix_search_path: NixSearchPath,
 
     observer: &'o mut dyn RuntimeObserver,
 }
@@ -142,9 +142,9 @@ macro_rules! cmp_op {
 }
 
 impl<'o> VM<'o> {
-    pub fn new(nix_path: NixPath, observer: &'o mut dyn RuntimeObserver) -> Self {
+    pub fn new(nix_search_path: NixSearchPath, observer: &'o mut dyn RuntimeObserver) -> Self {
         Self {
-            nix_path,
+            nix_search_path,
             observer,
             frames: vec![],
             stack: vec![],
@@ -518,7 +518,10 @@ impl<'o> VM<'o> {
 
             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))?;
+                let resolved = self
+                    .nix_search_path
+                    .resolve(path)
+                    .map_err(|e| self.error(e))?;
                 self.push(resolved.into());
             }
 
@@ -887,11 +890,11 @@ fn unwrap_or_clone_rc<T: Clone>(rc: Rc<T>) -> T {
 }
 
 pub fn run_lambda(
-    nix_path: NixPath,
+    nix_search_path: NixSearchPath,
     observer: &mut dyn RuntimeObserver,
     lambda: Rc<Lambda>,
 ) -> EvalResult<RuntimeResult> {
-    let mut vm = VM::new(nix_path, observer);
+    let mut vm = VM::new(nix_search_path, observer);
     vm.enter_frame(lambda, Upvalues::with_capacity(0), 0)?;
     let value = vm.pop();
     vm.force_for_output(&value)?;