mod async_fn;
mod async_generator;
mod call;
mod coerce;
mod dynamic;
mod eval;
mod execute;
mod generator;
mod global;
mod jobs;
mod loader;
mod module;
mod property;
mod proxy;
mod proxy_call;
mod proxy_shape;
mod suspend;
pub use self::loader::ModuleLoader;
pub use self::module::{Graph, LinkError};
use self::call::Frame;
pub(crate) use self::jobs::Job;
pub(crate) use self::suspend::Suspended;
use crate::ast::UnaryOperator;
use crate::compile::Chunk;
use crate::heap::{EnvironmentId, Heap, PropertyKey, PropertyKind};
use crate::realm::Realm;
use crate::value::{Abrupt, Completion, Value};
use std::rc::Rc;
const MAX_REALM_CHAIN: usize = 1_000;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Fault {
StackUnderflow,
MissingConstant,
JumpOutOfRange,
MissingLocal,
UnmatchedPopHandler,
UnmatchedPopScope,
MissingFunction,
MissingScope,
ReturnWithNoCall,
YieldOutsideGenerator,
ImportMetaOutsideModule,
MissingReference,
NotAnObject,
UnbalancedStack,
}
#[derive(Debug, Clone, Copy)]
pub enum Outcome {
Value(Value),
Thrown(Value),
Interrupted,
}
#[derive(Debug, Clone, Copy)]
pub(super) struct Handler {
pub(super) target: u32,
pub(super) frames: usize,
pub(super) depth: usize,
pub(super) references: usize,
pub(super) environment: EnvironmentId,
}
pub(crate) struct Waiter {
pub(crate) block: crate::heap::Block,
pub(crate) byte: usize,
pub(crate) capability: crate::heap::Capability,
pub(crate) deadline: Option<std::time::Instant>,
}
pub struct Vm {
stack: Vec<Value>,
realm: Realm,
realms: Vec<Realm>,
escaped: Option<Value>,
handlers: Vec<Handler>,
frames: Vec<Frame>,
this_value: Value,
new_target: Value,
environment: EnvironmentId,
completion: Value,
waiters: Vec<Waiter>,
unhandled: Vec<crate::heap::ObjectId>,
modules: std::collections::BTreeMap<usize, loader::ModuleRecord>,
resolved: Graph,
edges: std::collections::BTreeMap<(String, String), String>,
keys: std::collections::BTreeMap<usize, String>,
loader: Option<Box<dyn ModuleLoader>>,
jobs: std::collections::VecDeque<Job>,
floor: Floor,
until_check: usize,
can_block: bool,
time_budget: Option<std::time::Duration>,
expires_at: Option<std::time::Instant>,
collect_after_growth: Option<usize>,
collected_at: usize,
collect_next: usize,
stopped: bool,
templates: std::collections::HashMap<execute::TemplateSite, crate::heap::ObjectId>,
resume_returns: bool,
references: Vec<dynamic::Resolved>,
reentries: usize,
}
pub(super) const HEAP_CHECK_INTERVAL: usize = 1_000;
#[derive(Debug, Clone, Copy, Default)]
struct Floor {
handlers: usize,
frames: usize,
}
impl Vm {
pub fn new(heap: &mut Heap) -> Self {
let first = Realm::new(heap, crate::heap::RealmId(0));
Self {
waiters: Vec::new(),
unhandled: Vec::new(),
modules: std::collections::BTreeMap::new(),
resolved: Graph::new(),
edges: std::collections::BTreeMap::new(),
keys: std::collections::BTreeMap::new(),
loader: None,
realm: first,
realms: vec![first],
escaped: None,
jobs: std::collections::VecDeque::new(),
stack: Vec::new(),
handlers: Vec::new(),
frames: Vec::new(),
environment: heap.new_environment(None, 0),
this_value: Value::Undefined,
new_target: Value::Undefined,
completion: Value::Undefined,
floor: Floor::default(),
references: Vec::new(),
until_check: 0,
can_block: false,
time_budget: None,
collect_after_growth: Some(1 << 20),
collected_at: 0,
collect_next: 0,
expires_at: None,
stopped: false,
templates: std::collections::HashMap::new(),
reentries: 0,
resume_returns: false,
}
}
pub fn run_module(&mut self, chunk: &Chunk, heap: &mut Heap) -> Result<Outcome, Fault> {
let environment =
heap.new_named_environment(None, chunk.locals(), Rc::clone(chunk.bindings()));
self.modules
.entry(std::ptr::from_ref(chunk) as usize)
.or_insert_with(|| loader::ModuleRecord {
environment,
namespace: None,
import_meta: None,
evaluated: true,
failure: None,
});
self.run_prepared(chunk, environment, Value::Undefined, heap)
}
fn run_module_in(
&mut self,
chunk: &Chunk,
environment: crate::heap::EnvironmentId,
heap: &mut Heap,
) -> Result<Outcome, Fault> {
self.run_prepared(chunk, environment, Value::Undefined, heap)
}
fn run_async_module(
&mut self,
chunk: &Rc<Chunk>,
environment: crate::heap::EnvironmentId,
heap: &mut Heap,
) -> Result<Result<Value, Value>, Fault> {
let floor = std::mem::replace(
&mut self.floor,
Floor {
handlers: self.handlers.len(),
frames: self.frames.len(),
},
);
let base = self.stack.len();
let handlers_base = self.handlers.len();
let outer_environment = self.environment;
let outer_this = self.this_value;
let outer_target = self.new_target;
self.environment = environment;
self.this_value = Value::Undefined;
self.new_target = Value::Undefined;
let Some(context) = self.begin_async(heap) else {
return Err(Fault::NotAnObject);
};
let Some(capability) = self.capability_of(context, heap) else {
return Err(Fault::NotAnObject);
};
let promise = capability.promise;
let root = Chunk::from_parts(Vec::new(), Vec::new());
let mut current: Option<Rc<Chunk>> = Some(Rc::clone(chunk));
let mut at = 0_usize;
self.frames.push(Frame {
code: None,
at: 0,
this_value: outer_this,
new_target: outer_target,
realm: self.realm.id(),
environment: outer_environment,
stack_base: base,
handlers_base,
constructed: None,
function: None,
generator: Some(context),
});
let ran = self.execute(&root, heap, &mut current, &mut at);
self.stack.truncate(base);
self.handlers.truncate(handlers_base);
self.floor = floor;
self.environment = outer_environment;
self.this_value = outer_this;
self.new_target = outer_target;
ran?;
if let Some(thrown) = self.escaped.take() {
return Ok(Err(thrown));
}
Ok(Ok(promise))
}
pub fn realm(&self) -> Realm {
self.realm
}
#[must_use]
pub fn realm_by_id(&self, id: crate::heap::RealmId) -> Realm {
self.realms
.get(id.0 as usize)
.copied()
.unwrap_or(self.realm)
}
#[must_use]
pub fn own_realm(&self, function: crate::heap::ObjectId, heap: &Heap) -> Option<Realm> {
let object = heap.object(function)?;
if object.proxy().is_some() {
return None;
}
match object.call()? {
crate::heap::Callable::Bytecode { realm, .. }
| crate::heap::Callable::Native { realm, .. } => Some(self.realm_by_id(*realm)),
_ => None,
}
}
#[must_use]
pub fn realm_of(&self, function: crate::heap::ObjectId, heap: &Heap) -> Realm {
let mut at = function;
for _ in 0..MAX_REALM_CHAIN {
let Some(object) = heap.object(at) else {
return self.realm;
};
if let Some(proxy) = object.proxy() {
match proxy.parts() {
Some((target, _)) => at = target,
None => return self.realm,
}
continue;
}
match object.call() {
Some(crate::heap::Callable::Bytecode { realm, .. })
| Some(crate::heap::Callable::Native { realm, .. }) => {
return self.realm_by_id(*realm);
}
Some(crate::heap::Callable::Bound(bound)) => at = bound.target,
_ => return self.realm,
}
}
self.realm
}
pub fn create_realm(&mut self, heap: &mut Heap) -> Realm {
let id = crate::heap::RealmId(u32::try_from(self.realms.len()).unwrap_or(u32::MAX));
let realm = Realm::new(heap, id);
self.realms.push(realm);
realm
}
pub fn run(&mut self, chunk: &Chunk, heap: &mut Heap) -> Result<Outcome, Fault> {
let global = Value::Object(self.realm.global());
self.run_with_this(chunk, global, heap)
}
fn run_with_this(
&mut self,
chunk: &Chunk,
this_value: Value,
heap: &mut Heap,
) -> Result<Outcome, Fault> {
let environment =
heap.new_named_environment(None, chunk.locals(), Rc::clone(chunk.bindings()));
self.run_prepared(chunk, environment, this_value, heap)
}
fn run_prepared(
&mut self,
chunk: &Chunk,
environment: crate::heap::EnvironmentId,
this_value: Value,
heap: &mut Heap,
) -> Result<Outcome, Fault> {
self.stack.clear();
self.handlers.clear();
self.frames.clear();
self.escaped = None;
self.stopped = false;
self.unhandled.clear();
self.expires_at = self
.time_budget
.map(|budget| std::time::Instant::now() + budget);
self.begin_collection_window(heap);
self.completion = Value::Undefined;
self.environment = environment;
self.this_value = this_value;
self.new_target = Value::Undefined;
let mut current: Option<Rc<Chunk>> = None;
let mut at = 0_usize;
self.execute(chunk, heap, &mut current, &mut at)?;
if self.stopped {
return Ok(Outcome::Interrupted);
}
let escaped = self.escaped.take();
self.drain_jobs(chunk, heap);
self.escaped = None;
if let Some(thrown) = escaped {
return Ok(Outcome::Thrown(thrown));
}
if !self.stack.is_empty() {
return Err(Fault::UnbalancedStack);
}
Ok(Outcome::Value(self.completion))
}
fn enumerate_next(
&mut self,
object: Value,
keys: u32,
index: u32,
heap: &mut Heap,
) -> Result<Completion<Value>, Fault> {
loop {
let at = match heap.variable(self.environment, index) {
Some(Some(Value::Number(at))) => at,
_ => return Err(Fault::MissingLocal),
};
let Some(Some(Value::Object(list))) = heap.variable(self.environment, keys) else {
return Err(Fault::MissingLocal);
};
let position = u32::try_from(at as u64).unwrap_or(u32::MAX);
let slot = heap.index_key(position);
let Some(next) = heap
.object(list)
.and_then(|found| found.get_own_property(slot))
else {
return Ok(Ok(Value::Undefined));
};
let PropertyKind::Data { value, .. } = next.kind else {
return Err(Fault::MissingLocal);
};
if !heap.set_variable(self.environment, index, Value::Number(at + 1.0)) {
return Err(Fault::MissingLocal);
}
let Value::String(name) = value else {
return Err(Fault::MissingLocal);
};
let key = PropertyKey::from_string(heap, name);
if let Value::Object(_) = object {
match self.has_property_key(object, key, heap) {
Ok(false) => continue,
Ok(true) => {}
Err(error) => return Ok(Err(error)),
}
}
return Ok(Ok(value));
}
}
pub(super) fn raise(
&mut self,
error: Abrupt,
heap: &mut Heap,
root: &Chunk,
current: &mut Option<Rc<Chunk>>,
at: &mut usize,
) -> Result<(), Fault> {
let thrown = self.thrown_value(error, heap);
self.unwind(thrown, root, current, at)?;
Ok(())
}
pub(crate) fn thrown_value(&self, error: Abrupt, heap: &mut Heap) -> Value {
match error {
Abrupt::Raised(kind, message) => self.realm.error(heap, kind, message),
Abrupt::Thrown(value) => value,
}
}
fn settle(
&mut self,
outcome: Completion<Value>,
heap: &mut Heap,
root: &Chunk,
current: &mut Option<Rc<Chunk>>,
at: &mut usize,
) -> Result<Option<Value>, Fault> {
let error = match outcome {
Ok(value) => return Ok(Some(value)),
Err(error) => error,
};
let thrown = self.thrown_value(error, heap);
self.unwind(thrown, root, current, at)
}
fn unwind(
&mut self,
thrown: Value,
root: &Chunk,
current: &mut Option<Rc<Chunk>>,
at: &mut usize,
) -> Result<Option<Value>, Fault> {
let found = match self.handlers.len() > self.floor.handlers {
true => self.handlers.pop(),
false => None,
};
let Some(handler) = found else {
self.escaped = Some(thrown);
self.frames.truncate(self.floor.frames);
*current = None;
*at = root.code().len();
return Ok(None);
};
while self.frames.len() > handler.frames {
let Some(frame) = self.frames.pop() else {
return Err(Fault::ReturnWithNoCall);
};
self.environment = frame.environment;
self.this_value = frame.this_value;
self.new_target = frame.new_target;
self.realm = self.realm_by_id(frame.realm);
*current = frame.code;
*at = frame.at;
}
let length = current.as_deref().unwrap_or(root).code().len();
self.environment = handler.environment;
self.stack.truncate(handler.depth);
self.references.truncate(handler.references);
self.stack.push(thrown);
*at = jump_to(handler.target, length)?;
Ok(None)
}
pub fn set_time_budget(&mut self, budget: Option<std::time::Duration>) {
self.time_budget = budget;
}
pub(super) fn begin_collection_window(&mut self, heap: &Heap) {
self.collected_at = heap.footprint();
self.collect_next = self.collect_after_growth.unwrap_or(0);
}
pub fn set_collection_growth(&mut self, growth: Option<usize>) {
self.collect_after_growth = growth;
}
pub fn collect(&self, root: &Chunk, heap: &mut Heap) -> crate::heap::Collected {
let roots = self.roots(root, None);
heap.collect(&roots)
}
fn collection_is_due(&self, heap: &Heap) -> bool {
self.collect_after_growth.is_some()
&& self
.collect_next
.saturating_sub(heap.footprint().saturating_sub(self.collected_at))
== 0
}
fn settle_collection_window(&mut self, heap: &Heap) {
self.collected_at = heap.footprint();
self.collect_next = self
.collect_after_growth
.unwrap_or(0)
.max(heap.live_footprint());
}
fn collect_running(
&self,
root: &Chunk,
running: Option<&Chunk>,
heap: &mut Heap,
) -> crate::heap::Collected {
let roots = self.roots(root, running);
heap.collect(&roots)
}
pub(crate) fn legacy_caller_of(&self, function: crate::heap::ObjectId, heap: &Heap) -> Value {
let Some(at) = self
.frames
.iter()
.rposition(|frame| frame.function == Some(function))
else {
return Value::Null;
};
let below = match at.checked_sub(1) {
Some(below) => below,
None => return Value::Null,
};
match self.frames[below].function {
Some(caller) if crate::builtins::function::sloppy_caller(heap, caller) => {
Value::Object(caller)
}
_ => Value::Null,
}
}
pub(crate) fn can_block(&self) -> bool {
self.can_block
}
pub fn set_can_block(&mut self, can: bool) {
self.can_block = can;
}
pub(crate) fn park_waiter(
&mut self,
block: crate::heap::Block,
byte: usize,
capability: crate::heap::Capability,
timeout: Option<std::time::Duration>,
) {
self.waiters.push(Waiter {
block,
byte,
capability,
deadline: timeout.and_then(|timeout| std::time::Instant::now().checked_add(timeout)),
});
}
pub(crate) fn rejection_unhandled(&mut self, promise: crate::heap::ObjectId) {
self.unhandled.push(promise);
}
pub(crate) fn rejection_handled(&mut self, promise: crate::heap::ObjectId) {
self.unhandled.retain(|listed| *listed != promise);
}
#[must_use]
pub fn unhandled_rejections(&self) -> &[crate::heap::ObjectId] {
&self.unhandled
}
pub(crate) fn expire_waiters(&mut self, heap: &mut Heap) -> bool {
let now = std::time::Instant::now();
let mut expired = Vec::new();
self.waiters.retain(|waiter| {
let passed = waiter
.deadline
.is_some_and(|deadline| deadline.saturating_duration_since(now).is_zero());
if passed {
expired.push(waiter.capability);
}
!passed
});
if expired.is_empty() {
return false;
}
let timed_out = crate::builtins::text(heap, "timed-out");
for capability in expired {
let _ = self.settle_capability(
capability,
crate::heap::ReactionKind::Fulfil,
timed_out,
heap,
);
}
true
}
fn next_deadline(&self) -> Option<std::time::Instant> {
self.waiters
.iter()
.filter_map(|waiter| waiter.deadline)
.min()
}
fn wait_for_a_deadline(&mut self, heap: &mut Heap) -> bool {
let Some(deadline) = self.next_deadline() else {
return false;
};
let until = self.expires_at.map_or(deadline, |expires| {
std::cmp::min::<std::time::Instant>(expires, deadline)
});
std::thread::sleep(until.saturating_duration_since(std::time::Instant::now()));
self.expire_waiters(heap)
}
pub(crate) fn take_waiters(
&mut self,
block: &crate::heap::Block,
byte: usize,
count: f64,
) -> Vec<crate::heap::Capability> {
let mut taken = Vec::new();
let mut left = count;
self.waiters.retain(|waiter| {
if left > 0.0 && waiter.block.is(block) && waiter.byte == byte {
taken.push(waiter.capability);
left -= 1.0;
return false;
}
true
});
taken
}
fn roots(&self, root: &Chunk, running: Option<&Chunk>) -> crate::heap::Roots {
let mut values = Vec::new();
let mut environments = vec![self.environment];
if let Some(chunk) = running {
chunk.names(&mut values); }
values.extend(self.stack.iter().copied());
values.extend([self.this_value, self.new_target, self.completion]);
values.extend(self.escaped);
values.extend(self.templates.values().copied().map(Value::Object));
for realm in &self.realms {
values.extend(realm.intrinsics().map(Value::Object));
}
root.names(&mut values);
for frame in &self.frames {
values.extend([frame.this_value, frame.new_target]);
values.extend(frame.constructed);
values.extend(frame.function.map(Value::Object));
values.extend(frame.generator.map(Value::Object));
environments.push(frame.environment);
if let Some(code) = &frame.code {
code.names(&mut values);
}
}
environments.extend(self.handlers.iter().map(|handler| handler.environment));
for job in &self.jobs {
job.names(&mut values);
}
values.extend(self.unhandled.iter().copied().map(Value::Object));
for (_, chunk) in self.resolved.entries() {
chunk.names(&mut values);
}
for waiter in &self.waiters {
values.extend([
waiter.capability.promise,
waiter.capability.resolve,
waiter.capability.reject,
]);
}
for record in self.modules.values() {
environments.push(record.environment);
values.extend(record.namespace.map(Value::Object));
values.extend(record.failure);
values.extend(record.import_meta.map(Value::Object));
}
crate::heap::Roots {
values,
environments,
}
}
fn pop(&mut self) -> Result<Value, Fault> {
self.stack.pop().ok_or(Fault::StackUnderflow)
}
}
pub(super) fn jump_to(target: u32, length: usize) -> Result<usize, Fault> {
let target = target as usize;
if target > length {
return Err(Fault::JumpOutOfRange);
}
Ok(target)
}
fn apply_unary(operator: UnaryOperator, operand: Value, heap: &mut Heap) -> Completion<Value> {
Ok(match operator {
UnaryOperator::Void => Value::Undefined,
UnaryOperator::Typeof => {
let text = operand.type_of(heap);
Value::String(heap.new_string(text.encode_utf16().collect()))
}
UnaryOperator::Plus => Value::Number(operand.to_number(heap)?),
UnaryOperator::Minus => match operand {
Value::BigInt(id) => {
let negated = heap
.bigint(id)
.map_or_else(crate::bigint::BigInt::zero, crate::bigint::BigInt::negate);
Value::BigInt(heap.new_bigint(negated))
}
_ => Value::Number(-operand.to_number(heap)?),
},
UnaryOperator::BitwiseNot => match operand {
Value::BigInt(id) => {
let value = heap
.bigint(id)
.cloned()
.unwrap_or_else(crate::bigint::BigInt::zero);
match value.not() {
Ok(complement) => Value::BigInt(heap.new_bigint(complement)),
Err(_) => {
return Err(Abrupt::range_error(
"this BigInt is larger than this engine will hold",
));
}
}
}
_ => Value::Number(f64::from(!operand.to_int32(heap)?)),
},
UnaryOperator::LogicalNot => Value::Boolean(!operand.to_boolean(heap)),
UnaryOperator::Delete => Value::Undefined,
})
}
#[cfg(test)]
mod tests;