refactor(tvix/eval) s/NixPath/NixSearchPath/ r/5113

Since NixString is the Rust type for nix strings, people might
mistake NixPath for the Rust type of nix paths, which it is not.
Let's call it NixSearchPath instead.

Signed-off-by: Adam Joseph <adam@westernsemico.com>
Change-Id: Ib2ea155c4b27cb90d6180a04ea7b951d86607373
Reviewed-on: https://cl.tvl.fyi/c/depot/+/6927
Reviewed-by: kanepyork <rikingcoding@gmail.com>
Tested-by: BuildkiteCI
Reviewed-by: tazjin <tazjin@tvl.su>

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)?;