use crate::compile::{Chunk, compile_script};
use crate::heap::{Heap, Native, ObjectId, PropertyDescriptor, PropertyKey};
use crate::parser::parse_script;
use crate::value::{Completion, Value};
use crate::vm::{Fault, Outcome, Vm};
use std::rc::Rc;
pub struct Engine {
vm: Vm,
heap: Heap,
last: Rc<Chunk>,
}
pub struct Host<'a> {
vm: &'a mut Vm,
heap: &'a mut Heap,
}
impl<'a> Host<'a> {
pub fn new(vm: &'a mut Vm, heap: &'a mut Heap) -> Self {
Self { vm, heap }
}
pub fn text(&mut self, value: Value) -> Completion<String> {
let id = self.vm.to_string(value, self.heap)?;
Ok(self
.heap
.string(id)
.map(String::from_utf16_lossy)
.unwrap_or_default())
}
pub fn number(&mut self, value: Value) -> Completion<f64> {
self.vm.to_number(value, self.heap)
}
pub fn string(&mut self, text: &str) -> Value {
let units: Vec<u16> = text.encode_utf16().collect();
Value::String(self.heap.intern(&units))
}
pub fn get(&mut self, value: Value, name: &str) -> Completion<Value> {
let units: Vec<u16> = name.encode_utf16().collect();
let key = PropertyKey::from_units(self.heap, &units);
self.vm.get_property_key(value, key, self.heap)
}
pub fn call(
&mut self,
callee: Value,
this_value: Value,
arguments: &[Value],
) -> Completion<Value> {
self.vm.call_value(callee, this_value, arguments, self.heap)
}
pub fn eval_script(&mut self, source: &str) -> Completion<Value> {
crate::builtins::eval::source_as(
self.vm,
self.heap,
source,
crate::builtins::eval::Goal::Script,
)
}
#[must_use]
pub const fn type_error(message: &'static str) -> crate::value::Abrupt {
crate::value::Abrupt::type_error(message)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
Syntax {
message: String,
span: crate::span::Span,
},
Thrown(String),
Engine(Fault),
Interrupted,
Collected,
}
impl Default for Engine {
fn default() -> Self {
Self::new()
}
}
impl Engine {
#[must_use]
pub fn new() -> Self {
let mut heap = Heap::new();
let vm = Vm::new(&mut heap);
let empty = parse_script("").map(|script| compile_script(&script, &mut heap));
let chunk = match empty {
Ok(Ok(chunk)) => chunk,
_ => Chunk::default(),
};
Self {
vm,
heap,
last: Rc::new(chunk),
}
}
pub fn eval(&mut self, source: &str) -> Result<Value, Error> {
match self.eval_value(source)? {
Outcome::Value(value) => Ok(value),
Outcome::Thrown(value) => Err(Error::Thrown(self.describe(value))),
Outcome::Interrupted => Err(Error::Interrupted),
}
}
pub fn eval_value(&mut self, source: &str) -> Result<Outcome, Error> {
let script = parse_script(source).map_err(|error| Error::Syntax {
message: error.kind.to_string(),
span: error.span,
})?;
let chunk = compile_script(&script, &mut self.heap).map_err(|error| Error::Syntax {
message: error.message(),
span: error.span,
})?;
self.last = Rc::new(chunk);
let chunk = Rc::clone(&self.last);
self.vm.run(&chunk, &mut self.heap).map_err(Error::Engine)
}
#[must_use]
pub fn unhandled_rejections(&self) -> Vec<Value> {
self.vm
.unhandled_rejections()
.iter()
.map(|promise| {
self.heap
.promise(*promise)
.map_or(Value::Undefined, |found| found.result)
})
.collect()
}
pub fn text(&mut self, value: Value) -> Result<String, Error> {
if !self.live(value) {
return Err(Error::Collected);
}
match self.vm.to_string(value, &mut self.heap) {
Ok(id) => Ok(self
.heap
.string(id)
.map(String::from_utf16_lossy)
.unwrap_or_default()),
Err(abrupt) => Err(self.raised(abrupt)),
}
}
pub fn get(&mut self, value: Value, name: &str) -> Result<Value, Error> {
if !self.live(value) {
return Err(Error::Collected);
}
let key = self.key(name);
self.vm
.get_property_key(value, key, &mut self.heap)
.map_err(|abrupt| self.raised(abrupt))
}
pub fn call(
&mut self,
callee: Value,
this_value: Value,
arguments: &[Value],
) -> Result<Value, Error> {
if !self.live(callee) || !self.live(this_value) || !arguments.iter().all(|v| self.live(*v))
{
return Err(Error::Collected);
}
self.vm
.call_value(callee, this_value, arguments, &mut self.heap)
.map_err(|abrupt| self.raised(abrupt))
}
pub fn bind(&mut self, name: &str, length: u32, native: Native) {
let prototype = self.vm.realm().function_prototype();
let realm = self.vm.realm().id();
let function = self.heap.new_native_function(prototype, native, realm);
crate::builtins::define_function_metadata(&mut self.heap, function, name, length);
let _ = self.set_global(name, Value::Object(function));
}
pub fn bind_namespace(&mut self, name: &str, methods: &[(&str, u32, Native)]) {
let object = self
.heap
.new_object(Some(self.vm.realm().object_prototype()));
for (method, length, native) in methods {
let prototype = self.vm.realm().function_prototype();
let realm = self.vm.realm().id();
let function = self.heap.new_native_function(prototype, *native, realm);
let spelled = format!("{name}.{method}");
crate::builtins::define_function_metadata(&mut self.heap, function, &spelled, *length);
let key = self.key(method);
let _ = self.heap.define_own_property(
object,
key,
&PropertyDescriptor::data(Value::Object(function)),
);
}
let _ = self.set_global(name, Value::Object(object));
}
pub fn set_global(&mut self, name: &str, value: Value) -> Result<(), Error> {
if !self.live(value) {
return Err(Error::Collected);
}
let key = self.key(name);
let global = self.vm.realm().global();
let _ = self
.heap
.define_own_property(global, key, &PropertyDescriptor::data(value));
Ok(())
}
pub fn set_heap_budget(&mut self, bytes: usize) {
self.heap.set_budget(bytes);
}
#[must_use]
pub fn global(&self) -> ObjectId {
self.vm.realm().global()
}
pub fn set_time_budget(&mut self, budget: Option<std::time::Duration>) {
self.vm.set_time_budget(budget);
}
pub fn set_can_block(&mut self, can: bool) {
self.vm.set_can_block(can);
}
#[must_use]
pub fn realm(&self) -> crate::realm::Realm {
self.vm.realm()
}
#[must_use]
pub fn shared_block(&self, value: Value) -> Option<crate::heap::Block> {
let Value::Object(id) = value else {
return None;
};
self.heap
.object(id)
.and_then(crate::heap::Object::buffer)
.and_then(crate::heap::Buffer::block)
.cloned()
}
pub fn new_shared_buffer(&mut self, block: &crate::heap::Block) -> Value {
let object = self
.heap
.new_object(Some(self.vm.realm().shared_buffer_prototype()));
if let Some(found) = self.heap.object_mut(object) {
found.set_buffer(crate::heap::Buffer::over(block));
}
Value::Object(object)
}
pub fn collect(&mut self) -> crate::heap::Collected {
let root = Rc::clone(&self.last);
self.vm.collect(&root, &mut self.heap)
}
#[must_use]
pub fn footprint(&self) -> usize {
self.heap.footprint()
}
pub fn heap_mut(&mut self) -> &mut Heap {
&mut self.heap
}
fn live(&self, value: Value) -> bool {
match value {
Value::Object(id) => self.heap.object(id).is_some(),
Value::String(id) => self.heap.string(id).is_some(),
Value::Symbol(id) => self.heap.symbol(id).is_some(),
Value::BigInt(id) => self.heap.bigint(id).is_some(),
Value::Undefined | Value::Null | Value::Boolean(_) | Value::Number(_) => true,
}
}
fn raised(&mut self, abrupt: crate::value::Abrupt) -> Error {
let value = self.vm.thrown_value(abrupt, &mut self.heap);
Error::Thrown(self.describe(value))
}
fn key(&mut self, name: &str) -> PropertyKey {
let units: Vec<u16> = name.encode_utf16().collect();
PropertyKey::from_units(&mut self.heap, &units)
}
fn describe(&mut self, value: Value) -> String {
let Value::Object(_) = value else {
return self.spell(value);
};
let name = self.field(value, "name");
let message = self.field(value, "message");
match (name, message) {
(Some(name), Some(message)) if !name.is_empty() && !message.is_empty() => {
format!("{name}: {message}")
}
(Some(name), _) if !name.is_empty() => name,
_ => self.spell(value),
}
}
fn field(&mut self, value: Value, name: &str) -> Option<String> {
match self.get(value, name) {
Ok(Value::Undefined) | Err(_) => None,
Ok(found) => Some(self.spell(found)),
}
}
fn spell(&mut self, value: Value) -> String {
match self.vm.to_string(value, &mut self.heap) {
Ok(id) => self
.heap
.string(id)
.map(String::from_utf16_lossy)
.unwrap_or_default(),
Err(_) => "a value that will not print".to_string(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::heap::NativeCall;
use crate::value::Completion;
#[test]
fn the_heap_budget_is_the_hosts_to_choose_and_defaults_to_something_useful() {
let mut engine = Engine::new();
let answer = engine
.eval("var a = []; for (var i = 0; i < 5000; i++) a.push({x: i}); a.length")
.expect("the default budget allows an ordinary program");
assert_eq!(engine.text(answer).as_deref(), Ok("5000"));
let mut small = Engine::new();
small.set_heap_budget(1 << 16);
let refused = small.eval("var a = []; for (var i = 0; i < 200000; i++) a.push({x: i}); 1");
assert!(
matches!(&refused, Err(Error::Thrown(said)) if said.contains("heap has grown past")),
"{refused:?}"
);
let mut large = Engine::new();
large.set_heap_budget(1 << 28);
let answer = large
.eval("var a = []; for (var i = 0; i < 200000; i++) a.push({x: i}); a.length")
.expect("a raised budget allows it");
assert_eq!(large.text(answer).as_deref(), Ok("200000"));
}
#[test]
fn a_namespace_of_host_functions_is_an_ordinary_object_with_named_methods() {
fn answer(_: &mut Vm, _: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
Ok(call.argument(0))
}
let mut engine = Engine::new();
engine.bind_namespace("host", &[("echo", 1, answer), ("also", 2, answer)]);
let answer = engine
.eval("typeof host + ',' + Object.keys(host).join('|')")
.expect("runs");
assert_eq!(engine.text(answer).as_deref(), Ok("object,echo|also"));
let answer = engine.eval("host.echo(7)").expect("runs");
assert_eq!(engine.text(answer).as_deref(), Ok("7"));
let answer = engine
.eval("host.echo.name + ',' + host.echo.length + ',' + host.also.name")
.expect("runs");
assert_eq!(engine.text(answer).as_deref(), Ok("host.echo,1,host.also"));
let answer = engine
.eval("host.hasOwnProperty('echo') + ',' + ('toString' in host)")
.expect("runs");
assert_eq!(engine.text(answer).as_deref(), Ok("true,true"));
}
#[test]
fn a_script_answers_its_completion_value_and_the_host_reads_it_as_text() {
let mut engine = Engine::new();
let answer = engine.eval("1 + 1").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("2"));
let answer = engine.eval("1; 2").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("2"));
let answer = engine.eval("var x = 1").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("undefined"));
}
#[test]
fn a_syntax_error_says_where_and_not_only_what() {
let mut engine = Engine::new();
let source = "var a = 1;\nvar b = ;\nvar c = 3;";
let Err(Error::Syntax { message, span }) = engine.eval(source) else {
panic!("that does not parse");
};
let at = crate::span::line_col(source, span.start);
assert_eq!((at.line, at.column), (2, 9), "{message}");
assert_eq!(&source[span.start as usize..span.end as usize], ";");
let source = "var re = /(?<a>x)(?<a>y)/;";
let Err(Error::Syntax { span, .. }) = engine.eval(source) else {
panic!("a duplicate group name is an early error");
};
let at = crate::span::line_col(source, span.start);
assert_eq!(at.line, 1);
assert!(at.column > 1, "the pattern is not at the start of the line");
let source = "function f() {";
let Err(Error::Syntax { span, .. }) = engine.eval(source) else {
panic!("an unclosed body does not parse");
};
assert!(span.start as usize >= source.len() - 1);
}
#[test]
fn the_three_failures_are_told_apart_because_a_host_answers_them_differently() {
let mut engine = Engine::new();
assert!(matches!(engine.eval("1 +"), Err(Error::Syntax { .. })));
assert_eq!(
engine.eval("throw new TypeError('no')").unwrap_err(),
Error::Thrown("TypeError: no".to_string())
);
assert_eq!(
engine.eval("throw 7").unwrap_err(),
Error::Thrown("7".to_string())
);
assert_eq!(
engine.eval("null.x").unwrap_err(),
Error::Thrown(
"TypeError: cannot read a property of something that is not an object".to_string()
)
);
}
fn measure(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
let text = vm.to_string(call.argument(0), heap)?;
let length = heap.string(text).map_or(0, <[u16]>::len);
Ok(Value::Number(length as f64))
}
fn refuse(_: &mut Vm, _: &mut Heap, _: &NativeCall<'_>) -> Completion<Value> {
Err(crate::value::Abrupt::type_error("the host said no"))
}
#[test]
fn a_host_function_is_reachable_from_script_and_sees_its_arguments() {
let mut engine = Engine::new();
engine.bind("measure", 1, measure);
let answer = engine.eval("measure('abcd')").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("4"));
let answer = engine
.eval("measure.name + '/' + measure.length")
.expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("measure/1"));
let answer = engine
.eval("[1, 22, 333].map(function (n) { return measure(String(n)) }).join(',')")
.expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("1,2,3"));
}
#[test]
fn a_host_function_that_throws_is_caught_by_the_script() {
let mut engine = Engine::new();
engine.bind("refuse", 0, refuse);
let answer = engine
.eval("try { refuse() } catch (e) { e.constructor.name + ': ' + e.message }")
.expect("it runs");
assert_eq!(
engine.text(answer).as_deref(),
Ok("TypeError: the host said no")
);
assert_eq!(
engine.eval("refuse()").unwrap_err(),
Error::Thrown("TypeError: the host said no".to_string())
);
}
#[test]
fn a_value_crosses_the_boundary_in_both_directions() {
let mut engine = Engine::new();
let object = engine
.eval("({ a: 1, greet: function (who) { return 'hi ' + who } })")
.expect("it runs");
let a = engine.get(object, "a").expect("a is there");
assert_eq!(engine.text(a).as_deref(), Ok("1"));
let greet = engine.get(object, "greet").expect("greet is there");
let name = engine.eval("'world'").expect("it runs");
let said = engine.call(greet, object, &[name]).expect("it calls");
assert_eq!(engine.text(said).as_deref(), Ok("hi world"));
engine.set_global("held", object).expect("it is live");
let answer = engine.eval("held.a").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("1"));
}
#[test]
fn calling_something_that_is_not_a_function_throws_rather_than_faulting() {
let mut engine = Engine::new();
let not_callable = engine.eval("({})").expect("it runs");
assert!(matches!(
engine.call(not_callable, Value::Undefined, &[]),
Err(Error::Thrown(_))
));
assert!(matches!(
engine.get(Value::Undefined, "anything"),
Err(Error::Thrown(_))
));
}
fn shout(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
let mut host = Host::new(vm, heap);
let said = host.text(call.argument(0))?;
Ok(host.string(&said.to_uppercase()))
}
fn apply_to(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
let mut host = Host::new(vm, heap);
host.call(call.argument(0), Value::Undefined, &[call.argument(1)])
}
fn width_of(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
let mut host = Host::new(vm, heap);
let width = host.get(call.argument(0), "width")?;
match width {
Value::Number(_) => Ok(width),
_ => Err(Host::type_error("that has no numeric width")),
}
}
#[test]
fn a_native_can_do_its_work_with_only_what_a_host_can_reach() {
let mut engine = Engine::new();
engine.bind("shout", 1, shout);
engine.bind("applyTo", 2, apply_to);
engine.bind("widthOf", 1, width_of);
let answer = engine.eval("shout('hi') + shout(42)").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("HI42"));
let answer = engine
.eval("applyTo(function (n) { return n * 3 }, 7)")
.expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("21"));
let answer = engine.eval("widthOf({ width: 5 })").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("5"));
let answer = engine
.eval("try { widthOf({}) } catch (e) { e.constructor.name + ': ' + e.message }")
.expect("it runs");
assert_eq!(
engine.text(answer).as_deref(),
Ok("TypeError: that has no numeric width")
);
let answer = engine
.eval("try { shout(Symbol()) } catch (e) { e.constructor.name }")
.expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("TypeError"));
}
#[test]
fn a_string_a_native_makes_is_interned_rather_than_copied() {
let mut engine = Engine::new();
engine.bind("shout", 1, shout);
engine.eval("shout('warm')").expect("it runs");
let before = engine.footprint();
engine
.eval("for (var i = 0; i < 200; i++) { shout('warm') }")
.expect("it runs");
let grew = engine.footprint() - before;
assert!(
grew < 200 * std::mem::size_of::<u16>() * 4,
"200 answers of one word grew the heap by {grew} bytes"
);
}
const BUDGET: std::time::Duration = std::time::Duration::from_millis(50);
#[test]
fn a_script_that_will_not_stop_is_stopped() {
let mut engine = Engine::new();
engine.set_time_budget(Some(BUDGET));
assert_eq!(
engine.eval("while (true) {}").unwrap_err(),
Error::Interrupted
);
let answer = engine.eval("1 + 1").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("2"));
assert_eq!(engine.eval("for (;;) {}").unwrap_err(), Error::Interrupted);
}
#[test]
fn a_stopped_run_cannot_be_caught_and_runs_no_finally() {
let mut engine = Engine::new();
engine.set_time_budget(Some(BUDGET));
engine.eval("var reached = 'no'").expect("it runs");
assert_eq!(
engine
.eval("try { while (true) {} } catch (e) { reached = 'catch' }")
.unwrap_err(),
Error::Interrupted
);
let answer = engine.eval("reached").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("no"));
assert_eq!(
engine
.eval("try { while (true) {} } finally { reached = 'finally' }")
.unwrap_err(),
Error::Interrupted
);
let answer = engine.eval("reached").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("no"));
}
#[test]
fn a_stop_underneath_a_call_stops_the_caller_too() {
let mut engine = Engine::new();
engine.set_time_budget(Some(BUDGET));
engine.eval("var reached = 'no'").expect("it runs");
assert_eq!(
engine
.eval("[1].map(function () { while (true) {} }); reached = 'after the callback'")
.unwrap_err(),
Error::Interrupted
);
let answer = engine.eval("reached").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("no"));
assert_eq!(
engine
.eval("({ valueOf: function () { while (true) {} } }) + 1; reached = 'after the coercion'")
.unwrap_err(),
Error::Interrupted
);
let answer = engine.eval("reached").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("no"));
}
#[test]
fn a_stopped_run_drains_no_jobs() {
let mut engine = Engine::new();
engine.set_time_budget(Some(BUDGET));
engine.eval("var ran = 'no'").expect("it runs");
assert_eq!(
engine
.eval("Promise.resolve().then(function () { ran = 'yes' }); while (true) {}")
.unwrap_err(),
Error::Interrupted
);
let answer = engine.eval("ran").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("no"));
}
#[test]
fn a_waiters_timeout_never_outlasts_the_runs_budget() {
let mut engine = Engine::new();
engine.set_time_budget(Some(BUDGET));
let started = std::time::Instant::now();
engine
.eval(
"var a = new Int32Array(new SharedArrayBuffer(32)); \
Atomics.waitAsync(a, 0, 0, 5000);",
)
.expect("parking is not itself a runaway");
assert!(
started.elapsed() < std::time::Duration::from_secs(1),
"the run came back in {:?}, so it waited on the script's timeout",
started.elapsed()
);
}
#[test]
fn a_loop_inside_a_coercion_or_a_callback_is_stopped_too() {
let mut engine = Engine::new();
engine.set_time_budget(Some(BUDGET));
assert_eq!(
engine
.eval("({ valueOf: function () { while (true) {} } }) + 1")
.unwrap_err(),
Error::Interrupted
);
assert_eq!(
engine
.eval("[1, 2, 3].map(function () { while (true) {} })")
.unwrap_err(),
Error::Interrupted
);
assert_eq!(
engine
.eval("function* g() { while (true) { yield 1 } } for (var x of g()) {}")
.unwrap_err(),
Error::Interrupted
);
}
#[test]
fn no_budget_is_the_default_and_removing_one_restores_it() {
let mut engine = Engine::new();
let answer = engine
.eval("var n = 0; for (var i = 0; i < 200000; i++) { n += i } n")
.expect("no budget, so it finishes however long it takes");
assert_eq!(engine.text(answer).as_deref(), Ok("19999900000"));
engine.set_time_budget(Some(std::time::Duration::from_secs(30)));
let answer = engine
.eval("var n = 0; for (var i = 0; i < 200000; i++) { n += i } n")
.expect("well inside thirty seconds");
assert_eq!(engine.text(answer).as_deref(), Ok("19999900000"));
engine.set_time_budget(None);
let answer = engine.eval("1 + 1").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("2"));
}
#[test]
fn the_budget_does_not_reach_the_regular_expression_matcher() {
let mut engine = Engine::new();
engine.set_time_budget(Some(std::time::Duration::from_millis(10)));
let answer = engine
.eval("/(a+)+b/.test('aaaaaaaaaaaaaaaaaaaaaa')")
.expect("the matcher runs to the end, budget or no budget");
assert_eq!(engine.text(answer).as_deref(), Ok("false"));
let answer = engine.eval("1 + 1").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("2"));
}
#[test]
fn a_thrown_object_is_described_by_the_fields_it_actually_has() {
let mut engine = Engine::new();
let said = |engine: &mut Engine, source: &str| match engine.eval(source) {
Err(Error::Thrown(text)) => text,
other => panic!("expected a throw, got {other:?}"),
};
assert_eq!(
said(&mut engine, "throw new TypeError('no')"),
"TypeError: no"
);
assert_eq!(said(&mut engine, "throw new TypeError()"), "TypeError");
assert_eq!(said(&mut engine, "throw ({ name: 'Weird' })"), "Weird");
assert_eq!(
said(&mut engine, "throw ({ message: 'lonely' })"),
"[object Object]"
);
assert_eq!(said(&mut engine, "throw ({})"), "[object Object]");
assert_eq!(
said(&mut engine, "throw ({ name: '', message: 'm' })"),
"[object Object]"
);
assert_eq!(said(&mut engine, "throw 7"), "7");
assert_eq!(said(&mut engine, "throw 'plain'"), "plain");
assert_eq!(
said(
&mut engine,
"class Mine extends Error { constructor() { super('detail'); this.name = 'Mine' } } throw new Mine()"
),
"Mine: detail"
);
}
#[test]
fn a_collected_value_is_refused_and_never_read_as_undefined() {
let mut engine = Engine::new();
let held = engine.eval("({ a: 1 })").expect("it runs");
for _ in 0..50 {
engine.eval("({ junk: 1 })").expect("it runs");
}
assert!(engine.collect().objects > 0, "the collector did something");
assert_eq!(engine.get(held, "a").unwrap_err(), Error::Collected);
assert_eq!(engine.text(held), Err(Error::Collected));
assert_eq!(
engine.call(held, Value::Undefined, &[]).unwrap_err(),
Error::Collected
);
assert_eq!(engine.set_global("x", held), Err(Error::Collected));
let live = engine.eval("(function (x) { return x })").expect("it runs");
assert_eq!(
engine.call(live, Value::Undefined, &[held]).unwrap_err(),
Error::Collected
);
}
#[test]
fn the_global_object_is_how_a_host_roots_a_value() {
let mut engine = Engine::new();
let held = engine.eval("({ a: 1 })").expect("it runs");
engine.set_global("held", held).expect("it is live");
for _ in 0..50 {
engine.eval("({ junk: 1 })").expect("it runs");
}
engine.collect();
let a = engine.get(held, "a").expect("it survived");
assert_eq!(engine.text(a).as_deref(), Ok("1"));
let answer = engine.eval("held.a = 2; held.a").expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("2"));
let a = engine.get(held, "a").expect("still there");
assert_eq!(engine.text(a).as_deref(), Ok("2"));
}
#[test]
fn a_value_with_nothing_to_point_at_is_never_collected() {
let mut engine = Engine::new();
let number = engine.eval("42").expect("it runs");
let boolean = engine.eval("true").expect("it runs");
let nothing = engine.eval("null").expect("it runs");
let missing = engine.eval("undefined").expect("it runs");
for _ in 0..50 {
engine.eval("({ junk: 1 })").expect("it runs");
}
engine.collect();
assert_eq!(engine.text(number).as_deref(), Ok("42"));
assert_eq!(engine.text(boolean).as_deref(), Ok("true"));
assert_eq!(engine.text(nothing).as_deref(), Ok("null"));
assert_eq!(engine.text(missing).as_deref(), Ok("undefined"));
}
#[test]
fn two_engines_share_nothing() {
let mut first = Engine::new();
let mut second = Engine::new();
first.eval("var shared = 1").expect("it runs");
assert!(matches!(second.eval("shared"), Err(Error::Thrown(_))));
let answer = first.eval("shared").expect("it runs");
assert_eq!(first.text(answer).as_deref(), Ok("1"));
}
#[test]
fn two_agents_read_and_write_one_block() {
let mut main = Engine::new();
main.eval("var sab = new SharedArrayBuffer(8); var i32 = new Int32Array(sab)")
.expect("it runs");
let sab = main.eval("sab").expect("it runs");
let block = main.shared_block(sab).expect("a shared buffer has one");
let agent = std::thread::spawn(move || {
let mut engine = Engine::new();
let sab = engine.new_shared_buffer(&block);
engine.set_global("sab", sab).expect("it is live");
engine
.eval("new Int32Array(sab)[1] = 7")
.expect("it runs in the other agent");
});
agent.join().expect("the agent finished");
let answer = main.eval("i32[1]").expect("it runs");
assert_eq!(main.text(answer).as_deref(), Ok("7"));
}
#[test]
fn an_ordinary_array_buffer_has_no_block_to_share() {
let mut engine = Engine::new();
let unshared = engine.eval("new ArrayBuffer(8)").expect("it runs");
assert!(engine.shared_block(unshared).is_none());
let number = engine.eval("42").expect("it runs");
assert!(engine.shared_block(number).is_none());
let shared = engine.eval("new SharedArrayBuffer(8)").expect("it runs");
assert!(engine.shared_block(shared).is_some());
}
#[test]
fn an_engine_no_host_has_spoken_for_refuses_to_block() {
let mut engine = Engine::new();
let answer = engine
.eval(
"try { Atomics.wait(new Int32Array(new SharedArrayBuffer(8)), 0, 0, 0) } \
catch (e) { e.message }",
)
.expect("it runs");
assert_eq!(
engine.text(answer).as_deref(),
Ok("this agent cannot be suspended")
);
}
fn answered(engine: &mut Engine, source: &str) -> String {
let value = engine.eval(source).expect("it runs");
engine.text(value).expect("a string")
}
fn agent(block: crate::heap::Block, source: &'static str) -> std::thread::JoinHandle<String> {
std::thread::spawn(move || {
let mut engine = Engine::new();
engine.set_can_block(true);
let sab = engine.new_shared_buffer(&block);
engine.set_global("sab", sab).expect("it is live");
let value = engine.eval(source).expect("it runs in the other agent");
engine.text(value).expect("a string")
})
}
fn until(engine: &mut Engine, source: &str, wanted: &str, why: &str) {
for _ in 0..5_000 {
if answered(engine, source) == wanted {
return;
}
std::thread::sleep(std::time::Duration::from_millis(1));
}
panic!("{why}");
}
#[test]
fn a_native_can_convert_what_it_was_given_to_a_number() {
fn doubled(vm: &mut Vm, heap: &mut Heap, call: &NativeCall<'_>) -> Completion<Value> {
let mut host = Host::new(vm, heap);
let given = host.number(call.argument(0))?;
Ok(Value::Number(given * 2.0))
}
let mut engine = Engine::new();
engine.bind("doubled", 1, doubled);
assert_eq!(answered(&mut engine, "doubled('21')"), "42");
assert_eq!(
answered(
&mut engine,
"doubled({ valueOf: function () { return 4 } })"
),
"8"
);
assert_eq!(answered(&mut engine, "doubled()"), "NaN");
assert_eq!(
answered(
&mut engine,
"try { doubled(Symbol()) } catch (e) { e.constructor.name }"
),
"TypeError"
);
}
#[test]
fn a_wait_ends_at_its_timeout_and_a_stale_expectation_does_not_wait_at_all() {
let mut engine = Engine::new();
engine.set_can_block(true);
engine
.eval("var i32 = new Int32Array(new SharedArrayBuffer(8))")
.expect("it runs");
let started = std::time::Instant::now();
assert_eq!(
answered(&mut engine, "Atomics.wait(i32, 0, 0, 30)"),
"timed-out"
);
assert!(started.elapsed() >= std::time::Duration::from_millis(20));
engine.eval("i32[0] = 1").expect("it runs");
assert_eq!(
answered(&mut engine, "Atomics.wait(i32, 0, 0)"),
"not-equal"
);
}
#[test]
fn a_wait_reads_the_byte_its_index_names_and_the_value_as_the_slot_stores_it() {
let mut engine = Engine::new();
engine.set_can_block(true);
engine
.eval("var i32 = new Int32Array(new SharedArrayBuffer(16)); i32[0] = 5")
.expect("it runs");
assert_eq!(
answered(&mut engine, "Atomics.wait(i32, 1, 5, 0)"),
"not-equal"
);
assert_eq!(
answered(&mut engine, "Atomics.wait(i32, 0, 5, 0)"),
"timed-out"
);
engine.eval("i32[2] = -Math.pow(2, 31)").expect("it runs");
assert_eq!(
answered(&mut engine, "Atomics.wait(i32, 2, Math.pow(2, 31), 0)"),
"timed-out"
);
}
#[test]
fn a_wait_that_timed_out_has_taken_itself_off_the_list() {
let mut engine = Engine::new();
engine.set_can_block(true);
engine
.eval("var i32 = new Int32Array(new SharedArrayBuffer(16))")
.expect("it runs");
assert_eq!(
answered(&mut engine, "Atomics.wait(i32, 1, 0, 5)"),
"timed-out"
);
assert_eq!(answered(&mut engine, "Atomics.notify(i32, 1)"), "0");
}
#[test]
fn an_agent_that_may_block_waits_until_another_notifies_it() {
let mut main = Engine::new();
main.eval("var sab = new SharedArrayBuffer(8); var i32 = new Int32Array(sab)")
.expect("it runs");
let sab = main.eval("sab").expect("it runs");
let block = main.shared_block(sab).expect("a shared buffer has one");
let other = agent(block, "Atomics.wait(new Int32Array(sab), 0, 0)");
until(
&mut main,
"Atomics.notify(i32, 0)",
"1",
"the other agent never reached its wait",
);
assert_eq!(other.join().expect("the agent finished"), "ok");
}
#[test]
fn a_notify_wakes_only_the_position_it_names_and_only_as_many_as_it_was_asked_for() {
let mut main = Engine::new();
main.eval("var sab = new SharedArrayBuffer(16); var i32 = new Int32Array(sab)")
.expect("it runs");
let sab = main.eval("sab").expect("it runs");
let block = main.shared_block(sab).expect("a shared buffer has one");
let other = agent(block, "Atomics.wait(new Int32Array(sab), 1, 0, 30000)");
for _ in 0..100 {
assert_eq!(
answered(&mut main, "Atomics.notify(i32, 0)"),
"0",
"a notify at another position"
);
assert_eq!(
answered(&mut main, "Atomics.notify(i32, 1, 0)"),
"0",
"a notify of nobody at this one"
);
std::thread::sleep(std::time::Duration::from_millis(1));
}
until(
&mut main,
"Atomics.notify(i32, 1, 1)",
"1",
"the other agent never reached its wait",
);
assert_eq!(other.join().expect("the agent finished"), "ok");
}
#[test]
fn two_agents_adding_to_one_slot_lose_nothing() {
const EACH: usize = 20_000;
let mut main = Engine::new();
main.eval("var sab = new SharedArrayBuffer(8); var i32 = new Int32Array(sab)")
.expect("it runs");
let sab = main.eval("sab").expect("it runs");
let block = main.shared_block(sab).expect("a shared buffer has one");
let other = agent(
block,
"var a = new Int32Array(sab); \
for (var i = 0; i < 20000; i++) { Atomics.add(a, 0, 1); } 'done'",
);
main.eval("for (var i = 0; i < 20000; i++) { Atomics.add(i32, 0, 1); }")
.expect("it runs");
assert_eq!(other.join().expect("the agent finished"), "done");
assert_eq!(
answered(&mut main, "Atomics.load(i32, 0)"),
(EACH * 2).to_string()
);
}
#[test]
fn two_agents_incrementing_by_compare_exchange_lose_nothing() {
const EACH: usize = 10_000;
let mut main = Engine::new();
main.eval("var sab = new SharedArrayBuffer(8); var i32 = new Int32Array(sab)")
.expect("it runs");
let sab = main.eval("sab").expect("it runs");
let block = main.shared_block(sab).expect("a shared buffer has one");
let other = agent(
block,
"var a = new Int32Array(sab); \
for (var i = 0; i < 10000; i++) { \
var old; \
do { old = Atomics.load(a, 0); } \
while (Atomics.compareExchange(a, 0, old, old + 1) !== old); \
} 'done'",
);
main.eval(
"for (var i = 0; i < 10000; i++) { \
var old; \
do { old = Atomics.load(i32, 0); } \
while (Atomics.compareExchange(i32, 0, old, old + 1) !== old); \
}",
)
.expect("it runs");
assert_eq!(other.join().expect("the agent finished"), "done");
assert_eq!(
answered(&mut main, "Atomics.load(i32, 0)"),
(EACH * 2).to_string()
);
}
#[test]
fn a_notify_spends_its_count_on_parked_threads_before_its_own_promises() {
let mut main = Engine::new();
main.eval("var sab = new SharedArrayBuffer(16); var i32 = new Int32Array(sab)")
.expect("it runs");
let sab = main.eval("sab").expect("it runs");
let block = main.shared_block(sab).expect("a shared buffer has one");
let other = agent(
block,
"var a = new Int32Array(sab); Atomics.store(a, 1, 1); Atomics.wait(a, 0, 0, 30000)",
);
until(
&mut main,
"Atomics.load(i32, 1)",
"1",
"the other agent never started",
);
std::thread::sleep(std::time::Duration::from_millis(50));
main.eval("var parked = Atomics.waitAsync(i32, 0, 0)")
.expect("it runs");
assert_eq!(answered(&mut main, "Atomics.notify(i32, 0, 1)"), "1");
assert_eq!(other.join().expect("the agent finished"), "ok");
assert_eq!(answered(&mut main, "Atomics.notify(i32, 0)"), "1");
}
#[test]
fn the_job_queue_has_run_by_the_time_eval_returns() {
let mut engine = Engine::new();
let answer = engine
.eval("var seen = 'pending'; Promise.resolve(7).then(function (v) { seen = v }); 0")
.expect("it runs");
assert_eq!(engine.text(answer).as_deref(), Ok("0"));
let seen = engine.eval("seen").expect("it runs");
assert_eq!(engine.text(seen).as_deref(), Ok("7"));
}
#[test]
fn probe_completion_register_rooting() {
let mut e = Engine::new();
let a = e.eval("({ n: 1 })").expect("runs");
for _ in 0..50 {
e.eval("({ junk: 1 })").expect("runs");
}
let freed = e.collect();
println!("freed {:?}", freed.objects);
match e.get(a, "n") {
Ok(v) => println!("read gave Ok: {}", e.text(v).unwrap_or_default()),
Err(err) => println!("read gave Err: {err:?}"),
}
}
}