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

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
This commit is contained in:
Griffin Smith 2022-10-09 23:46:51 -04:00 committed by grfn
parent 5e2b44b416
commit 273ba73754
9 changed files with 77 additions and 21 deletions

View file

@ -286,9 +286,17 @@ fn eval(trace: bool, code: &str) -> Output {
}
let result = if trace {
tvix_eval::run_lambda(&mut TracingObserver::new(&mut out.trace), result.lambda)
tvix_eval::run_lambda(
Default::default(),
&mut TracingObserver::new(&mut out.trace),
result.lambda,
)
} else {
tvix_eval::run_lambda(&mut NoOpObserver::default(), result.lambda)
tvix_eval::run_lambda(
Default::default(),
&mut NoOpObserver::default(),
result.lambda,
)
};
match result {

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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