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

refactor(tvix/eval): add VM::call_value helper method

Browse source 
This makes it possible to call a callable value (builtin or
closure/lambda) directly, without unwrapping it first. This is needed
for pretty much all higher-order functions to work correctly.

This is mostly equivalent to the previous code in coerce_to_string for
calling `__toString`, except it expects the argument(s) to already be
placed on the stack.

Note that the span for the `NotCallable` error is not currently
guaranteed to make any sense, will experiment with this.

Change-Id: I821224368d438a28900858b343defc1817e46a0a
Reviewed-on: https://cl.tvl.fyi/c/depot/+/6717
Tested-by: BuildkiteCI
Reviewed-by: sterni <sternenseemann@systemli.org>
This commit is contained in:
Vincent Ambo 2022-09-21 00:32:49 +03:00 • committed by tazjin
parent f600aa5322
commit 8f2004d360
5 changed files with 32 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -175,7 +175,28 @@ impl<'o> VM<'o> {
}
}
#[allow(clippy::let_and_return)] // due to disassembler
/// Execute the given value in this VM's context, if it is a
/// callable.
///
/// The stack of the VM must be prepared with all required
/// arguments before calling this and the value must have already
/// been forced.
pub fn call_value(&mut self, callable: &Value) -> EvalResult<Value> {
match callable {
Value::Closure(c) => self.call(c.lambda(), c.upvalues().clone(), 1),
Value::Builtin(b) => {
self.call_builtin(b.clone())?;
Ok(self.pop())
}
Value::Thunk(t) => self.call_value(&t.value()),
// TODO: this isn't guaranteed to be a useful span, actually
_ => Err(self.error(ErrorKind::NotCallable)),
}
}
/// Execute the given lambda in this VM's context, returning its
/// value after its stack frame completes.
pub fn call(
@ -456,17 +477,7 @@ impl<'o> VM<'o> {
OpCode::OpCall => {
let callable = self.pop();
match callable {
Value::Closure(closure) => {
let result =
self.call(closure.lambda(), closure.upvalues().clone(), 1)?;
self.push(result)
}
Value::Builtin(builtin) => self.call_builtin(builtin)?,
_ => return Err(self.error(ErrorKind::NotCallable)),
};
self.call_value(&callable)?;
}
OpCode::OpTailCall => {