mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source 
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>
This commit is contained in:
Adam Joseph 2022-10-10 11:43:51 -07:00
parent 04fccd89a5
commit 32ac7d6c6d
5 changed files with 49 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
tvix/eval/src/eval.rs
View file

@ -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,
)

2
tvix/eval/src/lib.rs
View file

@ -12,7 +12,7 @@ mod value;
mod vm;
mod warnings;
mod nix_path;
mod nix_search_path;
#[cfg(test)]
mod properties;
#[cfg(test)]

64
tvix/eval/src/nix_path.rs → tvix/eval/src/nix_search_path.rs
View file

@ -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());
}
}

4
tvix/eval/src/opcode.rs
View file

@ -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

17
tvix/eval/src/vm.rs
View file

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