d978b556e6
This commit deduplicates the Thunk-like functionality from Closure and unifies it with Thunk. Specifically, we now have one and only one way of breaking reference cycles in the Value-graph: Thunk. No other variant contains a RefCell. This should make it easier to reason about the behavior of the VM. InnerClosure and UpvaluesCarrier are no longer necessary. This refactoring allowed an improvement in code generation: `Rc<RefCell<>>`s are now created only for closures which do not have self-references or deferred upvalues, instead of for all closures. OpClosure has been split into two separate opcodes: - OpClosure creates non-recursive closures with no deferred upvalues. The VM will not create an `Rc<RefCell<>>` when executing this instruction. - OpThunkClosure is used for closures with self-references or deferred upvalues. The VM will create a Thunk when executing this opcode, but the Thunk will start out already in the `ThunkRepr::Evaluated` state, rather than in the `ThunkRepr::Suspeneded` state. To avoid confusion, OpThunk has been renamed OpThunkSuspended. Thanks to @sterni for suggesting that all this could be done without adding an additional variant to ThunkRepr. This does however mean that there will be mutating accesses to `ThunkRepr::Evaluated`, which was not previously the case. The field `is_finalised:bool` has been added to `Closure` to ensure that these mutating accesses are performed only on finalised Closures. Both the check and the field are present only if `#[cfg(debug_assertions)]`. Change-Id: I04131501029772f30e28da8281d864427685097f Signed-off-by: Adam Joseph <adam@westernsemico.com> Reviewed-on: https://cl.tvl.fyi/c/depot/+/7019 Tested-by: BuildkiteCI Reviewed-by: tazjin <tazjin@tvl.su>
86 lines
2.8 KiB
Rust
86 lines
2.8 KiB
Rust
//! This module encapsulates some logic for upvalue handling, which is
|
|
//! relevant to both thunks (delayed computations for lazy-evaluation)
|
|
//! as well as closures (lambdas that capture variables from the
|
|
//! surrounding scope).
|
|
//!
|
|
//! The upvalues of a scope are whatever data are needed at runtime
|
|
//! in order to resolve each free variable in the scope to a value.
|
|
//! "Upvalue" is a term taken from Lua.
|
|
|
|
use std::ops::Index;
|
|
|
|
use crate::{opcode::UpvalueIdx, Value};
|
|
|
|
/// Structure for carrying upvalues of an UpvalueCarrier. The
|
|
/// implementation of this struct encapsulates the logic for
|
|
/// capturing and accessing upvalues.
|
|
///
|
|
/// Nix's `with` cannot be used to shadow an enclosing binding --
|
|
/// like Rust's `use xyz::*` construct, but unlike Javascript's
|
|
/// `with (xyz)`. This means that Nix has two kinds of identifiers,
|
|
/// which can be distinguished at compile time:
|
|
///
|
|
/// - Static identifiers, which are bound in some enclosing scope by
|
|
/// `let`, `name:` or `{name}:`
|
|
/// - Dynamic identifiers, which are not bound in any enclosing
|
|
/// scope
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Upvalues {
|
|
/// The upvalues of static identifiers. Each static identifier
|
|
/// is assigned an integer identifier at compile time, which is
|
|
/// an index into this Vec.
|
|
static_upvalues: Vec<Value>,
|
|
|
|
/// The upvalues of dynamic identifiers, if any exist. This
|
|
/// consists of the value passed to each enclosing `with val;`,
|
|
/// from outermost to innermost.
|
|
with_stack: Option<Vec<Value>>,
|
|
}
|
|
|
|
impl Upvalues {
|
|
pub fn with_capacity(count: usize) -> Self {
|
|
Upvalues {
|
|
static_upvalues: Vec::with_capacity(count),
|
|
with_stack: None,
|
|
}
|
|
}
|
|
|
|
/// Push an upvalue at the end of the upvalue list.
|
|
pub fn push(&mut self, value: Value) {
|
|
self.static_upvalues.push(value);
|
|
}
|
|
|
|
/// Set the captured with stack.
|
|
pub fn set_with_stack(&mut self, with_stack: Vec<Value>) {
|
|
self.with_stack = Some(with_stack);
|
|
}
|
|
|
|
pub fn with_stack(&self) -> Option<&Vec<Value>> {
|
|
self.with_stack.as_ref()
|
|
}
|
|
|
|
pub fn with_stack_len(&self) -> usize {
|
|
match &self.with_stack {
|
|
None => 0,
|
|
Some(stack) => stack.len(),
|
|
}
|
|
}
|
|
|
|
/// Resolve deferred upvalues from the provided stack slice,
|
|
/// mutating them in the internal upvalue slots.
|
|
pub fn resolve_deferred_upvalues(&mut self, stack: &[Value]) {
|
|
for upvalue in self.static_upvalues.iter_mut() {
|
|
if let Value::DeferredUpvalue(update_from_idx) = upvalue {
|
|
*upvalue = stack[update_from_idx.0].clone();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Index<UpvalueIdx> for Upvalues {
|
|
type Output = Value;
|
|
|
|
fn index(&self, index: UpvalueIdx) -> &Self::Output {
|
|
&self.static_upvalues[index.0]
|
|
}
|
|
}
|