Browse Source

Redesign native functions and closures API (#2499)

This PR is a complete redesign of our current native functions and closures API.

I was a bit dissatisfied with our previous design (even though I created it 😆), because it had a lot of superfluous traits, a forced usage of `Gc<GcCell<T>>` and an overly restrictive `NativeObject` bound. This redesign, on the other hand, simplifies a lot our public API, with a simple `NativeCallable` struct that has several constructors for each type of required native function.

This new design doesn't require wrapping every capture type with `Gc<GcCell<T>>`, relaxes the trait requirement to `Trace + 'static` for captures, can be reused in both `JsObject` functions and (soonish) host defined functions, and is (in my opinion) a bit cleaner than the previous iteration. It also offers an `unsafe` API as an escape hatch for users that want to pass non-Copy closures which don't capture traceable types.

Would ask for bikeshedding about the names though, because I don't know if `NativeCallable` is the most precise name for this. Same about the constructor names; I added the `from` prefix to all of them because it's the "standard" practice, but seeing the API doesn't have any other method aside from `call`, it may be better to just remove the prefix altogether.

Let me know what you think :)
pull/2524/head
José Julián Espina 2 years ago
parent
commit
edd404ba7f
  1. 7
      Cargo.lock
  2. 1
      boa_engine/Cargo.toml
  3. 16
      boa_engine/src/builtins/array/mod.rs
  4. 21
      boa_engine/src/builtins/array_buffer/mod.rs
  5. 3
      boa_engine/src/builtins/async_function/mod.rs
  6. 87
      boa_engine/src/builtins/async_generator/mod.rs
  7. 3
      boa_engine/src/builtins/async_generator_function/mod.rs
  8. 26
      boa_engine/src/builtins/dataview/mod.rs
  9. 3
      boa_engine/src/builtins/error/type.rs
  10. 5
      boa_engine/src/builtins/eval/mod.rs
  11. 152
      boa_engine/src/builtins/function/mod.rs
  12. 35
      boa_engine/src/builtins/function/tests.rs
  13. 3
      boa_engine/src/builtins/generator_function/mod.rs
  14. 62
      boa_engine/src/builtins/intl/collator/mod.rs
  15. 95
      boa_engine/src/builtins/intl/locale/mod.rs
  16. 45
      boa_engine/src/builtins/iterable/async_from_sync_iterator.rs
  17. 40
      boa_engine/src/builtins/map/mod.rs
  18. 4
      boa_engine/src/builtins/mod.rs
  19. 39
      boa_engine/src/builtins/number/mod.rs
  20. 49
      boa_engine/src/builtins/object/mod.rs
  21. 920
      boa_engine/src/builtins/promise/mod.rs
  22. 207
      boa_engine/src/builtins/promise/promise_job.rs
  23. 47
      boa_engine/src/builtins/proxy/mod.rs
  24. 95
      boa_engine/src/builtins/regexp/mod.rs
  25. 34
      boa_engine/src/builtins/set/mod.rs
  26. 23
      boa_engine/src/builtins/symbol/mod.rs
  27. 93
      boa_engine/src/builtins/typed_array/mod.rs
  28. 52
      boa_engine/src/builtins/uri/mod.rs
  29. 6
      boa_engine/src/class.rs
  30. 85
      boa_engine/src/context/mod.rs
  31. 1
      boa_engine/src/lib.rs
  32. 365
      boa_engine/src/native_function.rs
  33. 127
      boa_engine/src/object/builtins/jsproxy.rs
  34. 117
      boa_engine/src/object/mod.rs
  35. 45
      boa_engine/src/vm/code_block.rs
  36. 133
      boa_engine/src/vm/opcode/await_stm/mod.rs
  37. 157
      boa_examples/src/bin/closures.rs
  38. 40
      boa_examples/src/bin/jsarray.rs
  39. 16
      boa_examples/src/bin/jstypedarray.rs
  40. 7
      boa_examples/src/bin/modulehandler.rs
  41. 2
      boa_gc/src/internals/gc_box.rs
  42. 3
      boa_gc/src/internals/mod.rs
  43. 2
      boa_gc/src/lib.rs
  44. 36
      boa_gc/src/pointers/gc.rs
  45. 19
      boa_gc/src/trace.rs
  46. 55
      boa_tester/src/exec/mod.rs

7
Cargo.lock generated

@ -200,7 +200,6 @@ dependencies = [
"boa_profiler",
"chrono",
"criterion",
"dyn-clone",
"fast-float",
"float-cmp",
"icu_calendar",
@ -993,12 +992,6 @@ dependencies = [
"syn",
]
[[package]]
name = "dyn-clone"
version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c9b0705efd4599c15a38151f4721f7bc388306f61084d3bfd50bd07fbca5cb60"
[[package]]
name = "dynasm"
version = "1.2.3"

1
boa_engine/Cargo.toml

@ -57,7 +57,6 @@ ryu-js = "0.2.2"
chrono = "0.4.23"
fast-float = "0.2.0"
unicode-normalization = "0.1.22"
dyn-clone = "1.0.10"
once_cell = "1.17.0"
tap = "1.0.1"
sptr = "0.3.2"

16
boa_engine/src/builtins/array/mod.rs

@ -26,9 +26,10 @@ use crate::{
context::intrinsics::StandardConstructors,
error::JsNativeError,
js_string,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsFunction, JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsFunction, JsObject, ObjectData,
},
property::{Attribute, PropertyDescriptor, PropertyNameKind},
symbol::WellKnownSymbols,
@ -50,10 +51,11 @@ impl BuiltIn for Array {
let symbol_iterator = WellKnownSymbols::iterator();
let symbol_unscopables = WellKnownSymbols::unscopables();
let get_species = FunctionBuilder::native(context, Self::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_species =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_species))
.name("get [Symbol.species]")
.constructor(false)
.build();
let values_function = context.intrinsics().objects().array_prototype_values();
let unscopables_object = Self::unscopables_intrinsic(context);
@ -2847,7 +2849,7 @@ impl Array {
/// Creates an `Array.prototype.values( )` function object.
pub(crate) fn create_array_prototype_values(context: &mut Context<'_>) -> JsFunction {
FunctionBuilder::native(context, Self::values)
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::values))
.name("values")
.length(0)
.constructor(false)

21
boa_engine/src/builtins/array_buffer/mod.rs

@ -14,9 +14,10 @@ use crate::{
builtins::{typed_array::TypedArrayKind, BuiltIn, JsArgs},
context::intrinsics::StandardConstructors,
error::JsNativeError,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::Attribute,
symbol::WellKnownSymbols,
@ -55,14 +56,16 @@ impl BuiltIn for ArrayBuffer {
let flag_attributes = Attribute::CONFIGURABLE | Attribute::NON_ENUMERABLE;
let get_species = FunctionBuilder::native(context, Self::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_species =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_species))
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_byte_length = FunctionBuilder::native(context, Self::get_byte_length)
.name("get byteLength")
.build();
let get_byte_length =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_byte_length))
.name("get byteLength")
.build();
ConstructorBuilder::with_standard_constructor(
context,

3
boa_engine/src/builtins/async_function/mod.rs

@ -12,6 +12,7 @@ use crate::{
function::{ConstructorKind, Function},
BuiltIn,
},
native_function::NativeFunction,
object::ObjectData,
property::PropertyDescriptor,
symbol::WellKnownSymbols,
@ -62,7 +63,7 @@ impl BuiltIn for AsyncFunction {
.configurable(false);
constructor.borrow_mut().insert("prototype", property);
constructor.borrow_mut().data = ObjectData::function(Function::Native {
function: Self::constructor,
function: NativeFunction::from_fn_ptr(Self::constructor),
constructor: Some(ConstructorKind::Base),
});

87
boa_engine/src/builtins/async_generator/mod.rs

@ -11,7 +11,8 @@ use crate::{
promise::if_abrupt_reject_promise, promise::PromiseCapability, BuiltIn, JsArgs, Promise,
},
error::JsNativeError,
object::{ConstructorBuilder, FunctionBuilder, JsObject, ObjectData},
native_function::NativeFunction,
object::{ConstructorBuilder, FunctionObjectBuilder, JsObject, ObjectData},
property::{Attribute, PropertyDescriptor},
symbol::WellKnownSymbols,
value::JsValue,
@ -627,32 +628,34 @@ impl AsyncGenerator {
// 7. Let fulfilledClosure be a new Abstract Closure with parameters (value) that captures generator and performs the following steps when called:
// 8. Let onFulfilled be CreateBuiltinFunction(fulfilledClosure, 1, "", « »).
let on_fulfilled = FunctionBuilder::closure_with_captures(
let on_fulfilled = FunctionObjectBuilder::new(
context,
|_this, args, generator, context| {
let mut generator_borrow_mut = generator.borrow_mut();
let gen = generator_borrow_mut
.as_async_generator_mut()
.expect("already checked before");
NativeFunction::from_copy_closure_with_captures(
|_this, args, generator, context| {
let mut generator_borrow_mut = generator.borrow_mut();
let gen = generator_borrow_mut
.as_async_generator_mut()
.expect("already checked before");
// a. Set generator.[[AsyncGeneratorState]] to completed.
gen.state = AsyncGeneratorState::Completed;
// a. Set generator.[[AsyncGeneratorState]] to completed.
gen.state = AsyncGeneratorState::Completed;
// b. Let result be NormalCompletion(value).
let result = Ok(args.get_or_undefined(0).clone());
// b. Let result be NormalCompletion(value).
let result = Ok(args.get_or_undefined(0).clone());
// c. Perform AsyncGeneratorCompleteStep(generator, result, true).
let next = gen.queue.pop_front().expect("must have one entry");
drop(generator_borrow_mut);
Self::complete_step(&next, result, true, context);
// c. Perform AsyncGeneratorCompleteStep(generator, result, true).
let next = gen.queue.pop_front().expect("must have one entry");
drop(generator_borrow_mut);
Self::complete_step(&next, result, true, context);
// d. Perform AsyncGeneratorDrainQueue(generator).
Self::drain_queue(generator, context);
// d. Perform AsyncGeneratorDrainQueue(generator).
Self::drain_queue(generator, context);
// e. Return undefined.
Ok(JsValue::undefined())
},
generator.clone(),
// e. Return undefined.
Ok(JsValue::undefined())
},
generator.clone(),
),
)
.name("")
.length(1)
@ -660,32 +663,34 @@ impl AsyncGenerator {
// 9. Let rejectedClosure be a new Abstract Closure with parameters (reason) that captures generator and performs the following steps when called:
// 10. Let onRejected be CreateBuiltinFunction(rejectedClosure, 1, "", « »).
let on_rejected = FunctionBuilder::closure_with_captures(
let on_rejected = FunctionObjectBuilder::new(
context,
|_this, args, generator, context| {
let mut generator_borrow_mut = generator.borrow_mut();
let gen = generator_borrow_mut
.as_async_generator_mut()
.expect("already checked before");
NativeFunction::from_copy_closure_with_captures(
|_this, args, generator, context| {
let mut generator_borrow_mut = generator.borrow_mut();
let gen = generator_borrow_mut
.as_async_generator_mut()
.expect("already checked before");
// a. Set generator.[[AsyncGeneratorState]] to completed.
gen.state = AsyncGeneratorState::Completed;
// a. Set generator.[[AsyncGeneratorState]] to completed.
gen.state = AsyncGeneratorState::Completed;
// b. Let result be ThrowCompletion(reason).
let result = Err(JsError::from_opaque(args.get_or_undefined(0).clone()));
// b. Let result be ThrowCompletion(reason).
let result = Err(JsError::from_opaque(args.get_or_undefined(0).clone()));
// c. Perform AsyncGeneratorCompleteStep(generator, result, true).
let next = gen.queue.pop_front().expect("must have one entry");
drop(generator_borrow_mut);
Self::complete_step(&next, result, true, context);
// c. Perform AsyncGeneratorCompleteStep(generator, result, true).
let next = gen.queue.pop_front().expect("must have one entry");
drop(generator_borrow_mut);
Self::complete_step(&next, result, true, context);
// d. Perform AsyncGeneratorDrainQueue(generator).
Self::drain_queue(generator, context);
// d. Perform AsyncGeneratorDrainQueue(generator).
Self::drain_queue(generator, context);
// e. Return undefined.
Ok(JsValue::undefined())
},
generator,
// e. Return undefined.
Ok(JsValue::undefined())
},
generator,
),
)
.name("")
.length(1)

3
boa_engine/src/builtins/async_generator_function/mod.rs

@ -10,6 +10,7 @@ use crate::{
function::{BuiltInFunctionObject, ConstructorKind, Function},
BuiltIn,
},
native_function::NativeFunction,
object::ObjectData,
property::PropertyDescriptor,
symbol::WellKnownSymbols,
@ -67,7 +68,7 @@ impl BuiltIn for AsyncGeneratorFunction {
.configurable(false);
constructor.borrow_mut().insert("prototype", property);
constructor.borrow_mut().data = ObjectData::function(Function::Native {
function: Self::constructor,
function: NativeFunction::from_fn_ptr(Self::constructor),
constructor: Some(ConstructorKind::Base),
});

26
boa_engine/src/builtins/dataview/mod.rs

@ -11,9 +11,10 @@ use crate::{
builtins::{array_buffer::SharedMemoryOrder, typed_array::TypedArrayKind, BuiltIn, JsArgs},
context::intrinsics::StandardConstructors,
error::JsNativeError,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::Attribute,
symbol::WellKnownSymbols,
@ -37,17 +38,20 @@ impl BuiltIn for DataView {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let flag_attributes = Attribute::CONFIGURABLE | Attribute::NON_ENUMERABLE;
let get_buffer = FunctionBuilder::native(context, Self::get_buffer)
.name("get buffer")
.build();
let get_buffer =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_buffer))
.name("get buffer")
.build();
let get_byte_length = FunctionBuilder::native(context, Self::get_byte_length)
.name("get byteLength")
.build();
let get_byte_length =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_byte_length))
.name("get byteLength")
.build();
let get_byte_offset = FunctionBuilder::native(context, Self::get_byte_offset)
.name("get byteOffset")
.build();
let get_byte_offset =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_byte_offset))
.name("get byteOffset")
.build();
ConstructorBuilder::with_standard_constructor(
context,

3
boa_engine/src/builtins/error/type.rs

@ -19,6 +19,7 @@ use crate::{
builtins::{function::Function, BuiltIn, JsArgs},
context::intrinsics::StandardConstructors,
error::JsNativeError,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, JsObject, ObjectData,
},
@ -103,7 +104,7 @@ pub(crate) fn create_throw_type_error(context: &mut Context<'_>) -> JsObject {
let function = JsObject::from_proto_and_data(
context.intrinsics().constructors().function().prototype(),
ObjectData::function(Function::Native {
function: throw_type_error,
function: NativeFunction::from_fn_ptr(throw_type_error),
constructor: None,
}),
);

5
boa_engine/src/builtins/eval/mod.rs

@ -13,7 +13,8 @@ use crate::{
builtins::{BuiltIn, JsArgs},
environments::DeclarativeEnvironment,
error::JsNativeError,
object::FunctionBuilder,
native_function::NativeFunction,
object::FunctionObjectBuilder,
property::Attribute,
Context, JsResult, JsString, JsValue,
};
@ -37,7 +38,7 @@ impl BuiltIn for Eval {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let object = FunctionBuilder::native(context, Self::eval)
let object = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::eval))
.name("eval")
.length(1)
.constructor(false)

152
boa_engine/src/builtins/function/mod.rs

@ -18,11 +18,9 @@ use crate::{
environments::DeclarativeEnvironmentStack,
error::JsNativeError,
js_string,
object::{
internal_methods::get_prototype_from_constructor, JsObject, NativeObject, Object,
ObjectData,
},
object::{ConstructorBuilder, FunctionBuilder, JsFunction, PrivateElement, Ref, RefMut},
native_function::{NativeFunction, NativeFunctionPointer},
object::{internal_methods::get_prototype_from_constructor, JsObject, Object, ObjectData},
object::{ConstructorBuilder, FunctionObjectBuilder, JsFunction, PrivateElement},
property::{Attribute, PropertyDescriptor, PropertyKey},
string::utf16,
symbol::WellKnownSymbols,
@ -34,72 +32,20 @@ use boa_ast::{
operations::{bound_names, contains, lexically_declared_names, ContainsSymbol},
StatementList,
};
use boa_gc::{self, custom_trace, Finalize, Gc, GcCell, Trace};
use boa_gc::{self, custom_trace, Finalize, Gc, Trace};
use boa_interner::Sym;
use boa_parser::Parser;
use boa_profiler::Profiler;
use dyn_clone::DynClone;
use std::{
any::Any,
fmt,
ops::{Deref, DerefMut},
};
use tap::{Conv, Pipe};
use std::fmt;
use super::promise::PromiseCapability;
pub(crate) mod arguments;
#[cfg(test)]
mod tests;
/// Type representing a native built-in function a.k.a. function pointer.
///
/// Native functions need to have this signature in order to
/// be callable from Javascript.
///
/// # Arguments
///
/// - The first argument represents the `this` variable of every Javascript function.
///
/// - The second argument represents a list of all arguments passed to the function.
///
/// - The last argument is the [`Context`] of the engine.
pub type NativeFunctionSignature = fn(&JsValue, &[JsValue], &mut Context<'_>) -> JsResult<JsValue>;
// Allows restricting closures to only `Copy` ones.
// Used the sealed pattern to disallow external implementations
// of `DynCopy`.
mod sealed {
pub trait Sealed {}
impl<T: Copy> Sealed for T {}
}
/// This trait is implemented by any type that implements [`core::marker::Copy`].
pub trait DynCopy: sealed::Sealed {}
impl<T: Copy> DynCopy for T {}
/// Trait representing a native built-in closure.
///
/// Closures need to have this signature in order to
/// be callable from Javascript, but most of the time the compiler
/// is smart enough to correctly infer the types.
pub trait ClosureFunctionSignature:
Fn(&JsValue, &[JsValue], Captures, &mut Context<'_>) -> JsResult<JsValue>
+ DynCopy
+ DynClone
+ 'static
{
}
impl<T> ClosureFunctionSignature for T where
T: Fn(&JsValue, &[JsValue], Captures, &mut Context<'_>) -> JsResult<JsValue> + Copy + 'static
{
}
// Allows cloning Box<dyn ClosureFunctionSignature>
dyn_clone::clone_trait_object!(ClosureFunctionSignature);
/// Represents the `[[ThisMode]]` internal slot of function objects.
///
/// More information:
@ -196,47 +142,6 @@ unsafe impl Trace for ClassFieldDefinition {
}}
}
/// Wrapper for `Gc<GcCell<dyn NativeObject>>` that allows passing additional
/// captures through a `Copy` closure.
///
/// Any type implementing `Trace + Any + Debug`
/// can be used as a capture context, so you can pass e.g. a String,
/// a tuple or even a full struct.
///
/// You can cast to `Any` with `as_any`, `as_mut_any` and downcast
/// with `Any::downcast_ref` and `Any::downcast_mut` to recover the original
/// type.
#[derive(Clone, Debug, Trace, Finalize)]
pub struct Captures(Gc<GcCell<Box<dyn NativeObject>>>);
impl Captures {
/// Creates a new capture context.
pub(crate) fn new<T>(captures: T) -> Self
where
T: NativeObject,
{
Self(Gc::new(GcCell::new(Box::new(captures))))
}
/// Casts `Captures` to `Any`
///
/// # Panics
///
/// Panics if it's already borrowed as `&mut Any`
pub fn as_any(&self) -> boa_gc::GcCellRef<'_, dyn Any> {
Ref::map(self.0.borrow(), |data| data.deref().as_any())
}
/// Mutably casts `Captures` to `Any`
///
/// # Panics
///
/// Panics if it's already borrowed as `&mut Any`
pub fn as_mut_any(&self) -> boa_gc::GcCellRefMut<'_, Box<dyn NativeObject>, dyn Any> {
RefMut::map(self.0.borrow_mut(), |data| data.deref_mut().as_mut_any())
}
}
/// Boa representation of a Function Object.
///
/// `FunctionBody` is specific to this interpreter, it will either be Rust code or JavaScript code
@ -248,24 +153,11 @@ pub enum Function {
/// A rust function.
Native {
/// The rust function.
function: NativeFunctionSignature,
function: NativeFunction,
/// The kind of the function constructor if it is a constructor.
constructor: Option<ConstructorKind>,
},
/// A rust function that may contain captured values.
Closure {
/// The rust function.
function: Box<dyn ClosureFunctionSignature>,
/// The kind of the function constructor if it is a constructor.
constructor: Option<ConstructorKind>,
/// The captured values.
captures: Captures,
},
/// A bytecode function.
Ordinary {
/// The code block containing the compiled function.
@ -330,8 +222,7 @@ pub enum Function {
unsafe impl Trace for Function {
custom_trace! {this, {
match this {
Self::Native { .. } => {}
Self::Closure { captures, .. } => mark(captures),
Self::Native { function, .. } => {mark(function)}
Self::Ordinary { code, environments, home_object, fields, private_methods, .. } => {
mark(code);
mark(environments);
@ -367,9 +258,7 @@ impl Function {
/// Returns true if the function object is a constructor.
pub fn is_constructor(&self) -> bool {
match self {
Self::Native { constructor, .. } | Self::Closure { constructor, .. } => {
constructor.is_some()
}
Self::Native { constructor, .. } => constructor.is_some(),
Self::Generator { .. } | Self::AsyncGenerator { .. } | Self::Async { .. } => false,
Self::Ordinary { code, .. } => !(code.this_mode == ThisMode::Lexical),
}
@ -394,7 +283,7 @@ impl Function {
| Self::Async { home_object, .. }
| Self::Generator { home_object, .. }
| Self::AsyncGenerator { home_object, .. } => home_object.as_ref(),
_ => None,
Self::Native { .. } => None,
}
}
@ -405,7 +294,7 @@ impl Function {
| Self::Async { home_object, .. }
| Self::Generator { home_object, .. }
| Self::AsyncGenerator { home_object, .. } => *home_object = Some(object),
_ => {}
Self::Native { .. } => {}
}
}
@ -487,7 +376,7 @@ impl Function {
/// If no length is provided, the length will be set to 0.
// TODO: deprecate/remove this.
pub(crate) fn make_builtin_fn<N>(
function: NativeFunctionSignature,
function: NativeFunctionPointer,
name: N,
parent: &JsObject,
length: usize,
@ -505,7 +394,7 @@ pub(crate) fn make_builtin_fn<N>(
.function()
.prototype(),
ObjectData::function(Function::Native {
function,
function: NativeFunction::from_fn_ptr(function),
constructor: None,
}),
);
@ -905,7 +794,7 @@ impl BuiltInFunctionObject {
.unwrap_or_else(|| "anonymous".into());
match function {
Function::Native { .. } | Function::Closure { .. } | Function::Ordinary { .. } => {
Function::Native { .. } | Function::Ordinary { .. } => {
Ok(js_string!(utf16!("[Function: "), &name, utf16!("]")).into())
}
Function::Async { .. } => {
@ -949,7 +838,7 @@ impl BuiltIn for BuiltInFunctionObject {
let _timer = Profiler::global().start_event("function", "init");
let function_prototype = context.intrinsics().constructors().function().prototype();
FunctionBuilder::native(context, Self::prototype)
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::prototype))
.name("")
.length(0)
.constructor(false)
@ -957,11 +846,12 @@ impl BuiltIn for BuiltInFunctionObject {
let symbol_has_instance = WellKnownSymbols::has_instance();
let has_instance = FunctionBuilder::native(context, Self::has_instance)
.name("[Symbol.iterator]")
.length(1)
.constructor(false)
.build();
let has_instance =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::has_instance))
.name("[Symbol.iterator]")
.length(1)
.constructor(false)
.build();
let throw_type_error = context.intrinsics().objects().throw_type_error();

35
boa_engine/src/builtins/function/tests.rs

@ -1,7 +1,8 @@
use crate::{
error::JsNativeError,
forward, forward_val, js_string,
object::{FunctionBuilder, JsObject},
native_function::NativeFunction,
object::{FunctionObjectBuilder, JsObject},
property::{Attribute, PropertyDescriptor},
string::utf16,
Context, JsNativeErrorKind,
@ -244,22 +245,26 @@ fn closure_capture_clone() {
)
.unwrap();
let func = FunctionBuilder::closure_with_captures(
let func = FunctionObjectBuilder::new(
&mut context,
|_, _, captures, context| {
let (string, object) = &captures;
NativeFunction::from_copy_closure_with_captures(
|_, _, captures, context| {
let (string, object) = &captures;
let hw = js_string!(
string,
&object
.__get_own_property__(&"key".into(), context)?
.and_then(|prop| prop.value().cloned())
.and_then(|val| val.as_string().cloned())
.ok_or_else(|| JsNativeError::typ().with_message("invalid `key` property"))?
);
Ok(hw.into())
},
(string, object),
let hw = js_string!(
string,
&object
.__get_own_property__(&"key".into(), context)?
.and_then(|prop| prop.value().cloned())
.and_then(|val| val.as_string().cloned())
.ok_or_else(
|| JsNativeError::typ().with_message("invalid `key` property")
)?
);
Ok(hw.into())
},
(string, object),
),
)
.name("closure")
.build();

3
boa_engine/src/builtins/generator_function/mod.rs

@ -15,6 +15,7 @@ use crate::{
function::{BuiltInFunctionObject, ConstructorKind, Function},
BuiltIn,
},
native_function::NativeFunction,
object::ObjectData,
property::PropertyDescriptor,
symbol::WellKnownSymbols,
@ -72,7 +73,7 @@ impl BuiltIn for GeneratorFunction {
.configurable(false);
constructor.borrow_mut().insert("prototype", property);
constructor.borrow_mut().data = ObjectData::function(Function::Native {
function: Self::constructor,
function: NativeFunction::from_fn_ptr(Self::constructor),
constructor: Some(ConstructorKind::Base),
});

62
boa_engine/src/builtins/intl/collator/mod.rs

@ -14,9 +14,10 @@ use tap::{Conv, Pipe};
use crate::{
builtins::{BuiltIn, JsArgs},
context::{intrinsics::StandardConstructors, BoaProvider},
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsFunction, JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsFunction, JsObject, ObjectData,
},
property::Attribute,
symbol::WellKnownSymbols,
@ -160,10 +161,11 @@ impl BuiltIn for Collator {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let compare = FunctionBuilder::native(context, Self::compare)
.name("get compare")
.constructor(false)
.build();
let compare =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::compare))
.name("get compare")
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,
@ -415,32 +417,34 @@ impl Collator {
let bound_compare = if let Some(f) = collator.bound_compare.clone() {
f
} else {
let bound_compare = FunctionBuilder::closure_with_captures(
let bound_compare = FunctionObjectBuilder::new(
context,
// 10.3.3.1. Collator Compare Functions
// https://tc39.es/ecma402/#sec-collator-compare-functions
|_, args, collator, context| {
// 1. Let collator be F.[[Collator]].
// 2. Assert: Type(collator) is Object and collator has an [[InitializedCollator]] internal slot.
let collator = collator.borrow();
let collator = collator
.as_collator()
.expect("checked above that the object was a collator object");
// 3. If x is not provided, let x be undefined.
// 5. Let X be ? ToString(x).
let x = args.get_or_undefined(0).to_string(context)?;
// 4. If y is not provided, let y be undefined.
// 6. Let Y be ? ToString(y).
let y = args.get_or_undefined(1).to_string(context)?;
// 7. Return CompareStrings(collator, X, Y).
let result = collator.collator.compare_utf16(&x, &y) as i32;
Ok(result.into())
},
collator_obj,
NativeFunction::from_copy_closure_with_captures(
|_, args, collator, context| {
// 1. Let collator be F.[[Collator]].
// 2. Assert: Type(collator) is Object and collator has an [[InitializedCollator]] internal slot.
let collator = collator.borrow();
let collator = collator
.as_collator()
.expect("checked above that the object was a collator object");
// 3. If x is not provided, let x be undefined.
// 5. Let X be ? ToString(x).
let x = args.get_or_undefined(0).to_string(context)?;
// 4. If y is not provided, let y be undefined.
// 6. Let Y be ? ToString(y).
let y = args.get_or_undefined(1).to_string(context)?;
// 7. Return CompareStrings(collator, X, Y).
let result = collator.collator.compare_utf16(&x, &y) as i32;
Ok(result.into())
},
collator_obj,
),
)
.length(2)
.build();

95
boa_engine/src/builtins/intl/locale/mod.rs

@ -20,9 +20,10 @@ use crate::{
builtins::{BuiltIn, JsArgs},
context::intrinsics::StandardConstructors,
js_string,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::Attribute,
symbol::WellKnownSymbols,
@ -40,52 +41,62 @@ impl BuiltIn for Locale {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let base_name = FunctionBuilder::native(context, Self::base_name)
.name("get baseName")
.constructor(false)
.build();
let calendar = FunctionBuilder::native(context, Self::calendar)
.name("get calendar")
.constructor(false)
.build();
let case_first = FunctionBuilder::native(context, Self::case_first)
.name("get caseFirst")
.constructor(false)
.build();
let collation = FunctionBuilder::native(context, Self::collation)
.name("get collation")
.constructor(false)
.build();
let hour_cycle = FunctionBuilder::native(context, Self::hour_cycle)
.name("get hourCycle")
.constructor(false)
.build();
let numeric = FunctionBuilder::native(context, Self::numeric)
.name("get numeric")
.constructor(false)
.build();
let numbering_system = FunctionBuilder::native(context, Self::numbering_system)
.name("get numberingSystem")
.constructor(false)
.build();
let base_name =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::base_name))
.name("get baseName")
.constructor(false)
.build();
let calendar =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::calendar))
.name("get calendar")
.constructor(false)
.build();
let case_first =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::case_first))
.name("get caseFirst")
.constructor(false)
.build();
let collation =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::collation))
.name("get collation")
.constructor(false)
.build();
let hour_cycle =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::hour_cycle))
.name("get hourCycle")
.constructor(false)
.build();
let numeric =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::numeric))
.name("get numeric")
.constructor(false)
.build();
let numbering_system = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(Self::numbering_system),
)
.name("get numberingSystem")
.constructor(false)
.build();
let language = FunctionBuilder::native(context, Self::language)
.name("get language")
.constructor(false)
.build();
let language =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::language))
.name("get language")
.constructor(false)
.build();
let script = FunctionBuilder::native(context, Self::script)
let script = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::script))
.name("get script")
.constructor(false)
.build();
let region = FunctionBuilder::native(context, Self::region)
let region = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::region))
.name("get region")
.constructor(false)
.build();

45
boa_engine/src/builtins/iterable/async_from_sync_iterator.rs

@ -4,7 +4,8 @@ use crate::{
promise::{if_abrupt_reject_promise, PromiseCapability},
JsArgs, Promise,
},
object::{FunctionBuilder, JsObject, ObjectData},
native_function::NativeFunction,
object::{FunctionObjectBuilder, JsObject, ObjectData},
property::PropertyDescriptor,
Context, JsNativeError, JsResult, JsValue,
};
@ -29,18 +30,27 @@ pub(crate) fn create_async_from_sync_iterator_prototype(context: &mut Context<'_
ObjectData::ordinary(),
);
let next_function = FunctionBuilder::native(context, AsyncFromSyncIterator::next)
.name("next")
.length(1)
.build();
let return_function = FunctionBuilder::native(context, AsyncFromSyncIterator::r#return)
.name("return")
.length(1)
.build();
let throw_function = FunctionBuilder::native(context, AsyncFromSyncIterator::throw)
.name("throw")
.length(1)
.build();
let next_function = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(AsyncFromSyncIterator::next),
)
.name("next")
.length(1)
.build();
let return_function = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(AsyncFromSyncIterator::r#return),
)
.name("return")
.length(1)
.build();
let throw_function = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(AsyncFromSyncIterator::throw),
)
.name("throw")
.length(1)
.build();
{
let mut prototype_mut = prototype.borrow_mut();
@ -400,17 +410,16 @@ impl AsyncFromSyncIterator {
// 8. Let unwrap be a new Abstract Closure with parameters (value)
// that captures done and performs the following steps when called:
// 9. Let onFulfilled be CreateBuiltinFunction(unwrap, 1, "", « »).
let on_fulfilled = FunctionBuilder::closure_with_captures(
let on_fulfilled = FunctionObjectBuilder::new(
context,
|_this, args, done, context| {
NativeFunction::from_copy_closure(move |_this, args, context| {
// a. Return CreateIterResultObject(value, done).
Ok(create_iter_result_object(
args.get_or_undefined(0).clone(),
*done,
done,
context,
))
},
done,
}),
)
.name("")
.length(1)

40
boa_engine/src/builtins/map/mod.rs

@ -16,9 +16,10 @@ use crate::{
builtins::BuiltIn,
context::intrinsics::StandardConstructors,
error::JsNativeError,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::{Attribute, PropertyNameKind},
symbol::WellKnownSymbols,
@ -42,22 +43,25 @@ impl BuiltIn for Map {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let get_species = FunctionBuilder::native(context, Self::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_size = FunctionBuilder::native(context, Self::get_size)
.name("get size")
.length(0)
.constructor(false)
.build();
let entries_function = FunctionBuilder::native(context, Self::entries)
.name("entries")
.length(0)
.constructor(false)
.build();
let get_species =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_species))
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_size =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_size))
.name("get size")
.length(0)
.constructor(false)
.build();
let entries_function =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::entries))
.name("entries")
.length(0)
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,

4
boa_engine/src/builtins/mod.rs

@ -138,7 +138,7 @@ fn init_builtin<B: BuiltIn>(context: &mut Context<'_>) {
/// Initializes built-in objects and functions
pub fn init(context: &mut Context<'_>) {
macro_rules! globals {
($( $builtin:ty ),*) => {
($( $builtin:ty ),*$(,)?) => {
$(init_builtin::<$builtin>(context)
);*
}
@ -195,7 +195,7 @@ pub fn init(context: &mut Context<'_>) {
AsyncGenerator,
AsyncGeneratorFunction,
Uri,
WeakRef
WeakRef,
};
#[cfg(feature = "intl")]

39
boa_engine/src/builtins/number/mod.rs

@ -17,9 +17,10 @@ use crate::{
builtins::{string::is_trimmable_whitespace, BuiltIn, JsArgs},
context::intrinsics::StandardConstructors,
error::JsNativeError,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::Attribute,
string::utf16,
@ -50,17 +51,19 @@ impl BuiltIn for Number {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let parse_int = FunctionBuilder::native(context, Self::parse_int)
.name("parseInt")
.length(2)
.constructor(false)
.build();
let parse_int =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::parse_int))
.name("parseInt")
.length(2)
.constructor(false)
.build();
let parse_float = FunctionBuilder::native(context, Self::parse_float)
.name("parseFloat")
.length(1)
.constructor(false)
.build();
let parse_float =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::parse_float))
.name("parseFloat")
.length(1)
.constructor(false)
.build();
context.register_global_property(
"parseInt",
@ -73,8 +76,16 @@ impl BuiltIn for Number {
Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
);
context.register_global_builtin_function("isFinite", 1, Self::global_is_finite);
context.register_global_builtin_function("isNaN", 1, Self::global_is_nan);
context.register_global_builtin_callable(
"isFinite",
1,
NativeFunction::from_fn_ptr(Self::global_is_finite),
);
context.register_global_builtin_callable(
"isNaN",
1,
NativeFunction::from_fn_ptr(Self::global_is_nan),
);
let attribute = Attribute::READONLY | Attribute::NON_ENUMERABLE | Attribute::PERMANENT;

49
boa_engine/src/builtins/object/mod.rs

@ -21,9 +21,10 @@ use crate::{
context::intrinsics::StandardConstructors,
error::JsNativeError,
js_string,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
IntegrityLevel, JsObject, ObjectData, ObjectKind,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, IntegrityLevel, JsObject, ObjectData, ObjectKind,
},
property::{Attribute, PropertyDescriptor, PropertyKey, PropertyNameKind},
string::utf16,
@ -48,13 +49,19 @@ impl BuiltIn for Object {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let legacy_proto_getter = FunctionBuilder::native(context, Self::legacy_proto_getter)
.name("get __proto__")
.build();
let legacy_proto_getter = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(Self::legacy_proto_getter),
)
.name("get __proto__")
.build();
let legacy_setter_proto = FunctionBuilder::native(context, Self::legacy_proto_setter)
.name("set __proto__")
.build();
let legacy_setter_proto = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(Self::legacy_proto_setter),
)
.name("set __proto__")
.build();
ConstructorBuilder::with_standard_constructor(
context,
@ -1268,22 +1275,24 @@ impl Object {
// 4. Let closure be a new Abstract Closure with parameters (key, value) that captures
// obj and performs the following steps when called:
let closure = FunctionBuilder::closure_with_captures(
let closure = FunctionObjectBuilder::new(
context,
|_, args, obj, context| {
let key = args.get_or_undefined(0);
let value = args.get_or_undefined(1);
NativeFunction::from_copy_closure_with_captures(
|_, args, obj, context| {
let key = args.get_or_undefined(0);
let value = args.get_or_undefined(1);
// a. Let propertyKey be ? ToPropertyKey(key).
let property_key = key.to_property_key(context)?;
// a. Let propertyKey be ? ToPropertyKey(key).
let property_key = key.to_property_key(context)?;
// b. Perform ! CreateDataPropertyOrThrow(obj, propertyKey, value).
obj.create_data_property_or_throw(property_key, value.clone(), context)?;
// b. Perform ! CreateDataPropertyOrThrow(obj, propertyKey, value).
obj.create_data_property_or_throw(property_key, value.clone(), context)?;
// c. Return undefined.
Ok(JsValue::undefined())
},
obj.clone(),
// c. Return undefined.
Ok(JsValue::undefined())
},
obj.clone(),
),
);
// 5. Let adder be ! CreateBuiltinFunction(closure, 2, "", « »).

920
boa_engine/src/builtins/promise/mod.rs

File diff suppressed because it is too large Load Diff

207
boa_engine/src/builtins/promise/promise_job.rs

@ -2,7 +2,8 @@ use super::{Promise, PromiseCapability};
use crate::{
builtins::promise::{ReactionRecord, ReactionType},
job::JobCallback,
object::{FunctionBuilder, JsObject},
native_function::NativeFunction,
object::{FunctionObjectBuilder, JsObject},
Context, JsValue,
};
use boa_gc::{Finalize, Trace};
@ -27,75 +28,77 @@ impl PromiseJob {
}
// 1. Let job be a new Job Abstract Closure with no parameters that captures reaction and argument and performs the following steps when called:
let job = FunctionBuilder::closure_with_captures(
let job = FunctionObjectBuilder::new(
context,
|_this, _args, captures, context| {
let ReactionJobCaptures { reaction, argument } = captures;
let ReactionRecord {
// a. Let promiseCapability be reaction.[[Capability]].
promise_capability,
// b. Let type be reaction.[[Type]].
reaction_type,
// c. Let handler be reaction.[[Handler]].
handler,
} = reaction;
let handler_result = match handler {
// d. If handler is empty, then
None => match reaction_type {
// i. If type is Fulfill, let handlerResult be NormalCompletion(argument).
ReactionType::Fulfill => Ok(argument.clone()),
// ii. Else,
// 1. Assert: type is Reject.
ReactionType::Reject => {
// 2. Let handlerResult be ThrowCompletion(argument).
Err(argument.clone())
}
},
// e. Else, let handlerResult be Completion(HostCallJobCallback(handler, undefined, « argument »)).
Some(handler) => handler
.call_job_callback(&JsValue::Undefined, &[argument.clone()], context)
.map_err(|e| e.to_opaque(context)),
};
match promise_capability {
None => {
// f. If promiseCapability is undefined, then
// i. Assert: handlerResult is not an abrupt completion.
assert!(
handler_result.is_ok(),
"Assertion: <handlerResult is not an abrupt completion> failed"
);
// ii. Return empty.
Ok(JsValue::Undefined)
}
Some(promise_capability_record) => {
// g. Assert: promiseCapability is a PromiseCapability Record.
let PromiseCapability {
promise: _,
resolve,
reject,
} = promise_capability_record;
match handler_result {
// h. If handlerResult is an abrupt completion, then
Err(value) => {
// i. Return ? Call(promiseCapability.[[Reject]], undefined, « handlerResult.[[Value]] »).
reject.call(&JsValue::Undefined, &[value], context)
NativeFunction::from_copy_closure_with_captures(
|_this, _args, captures, context| {
let ReactionJobCaptures { reaction, argument } = captures;
let ReactionRecord {
// a. Let promiseCapability be reaction.[[Capability]].
promise_capability,
// b. Let type be reaction.[[Type]].
reaction_type,
// c. Let handler be reaction.[[Handler]].
handler,
} = reaction;
let handler_result = match handler {
// d. If handler is empty, then
None => match reaction_type {
// i. If type is Fulfill, let handlerResult be NormalCompletion(argument).
ReactionType::Fulfill => Ok(argument.clone()),
// ii. Else,
// 1. Assert: type is Reject.
ReactionType::Reject => {
// 2. Let handlerResult be ThrowCompletion(argument).
Err(argument.clone())
}
// i. Else,
Ok(value) => {
// i. Return ? Call(promiseCapability.[[Resolve]], undefined, « handlerResult.[[Value]] »).
resolve.call(&JsValue::Undefined, &[value], context)
},
// e. Else, let handlerResult be Completion(HostCallJobCallback(handler, undefined, « argument »)).
Some(handler) => handler
.call_job_callback(&JsValue::Undefined, &[argument.clone()], context)
.map_err(|e| e.to_opaque(context)),
};
match promise_capability {
None => {
// f. If promiseCapability is undefined, then
// i. Assert: handlerResult is not an abrupt completion.
assert!(
handler_result.is_ok(),
"Assertion: <handlerResult is not an abrupt completion> failed"
);
// ii. Return empty.
Ok(JsValue::Undefined)
}
Some(promise_capability_record) => {
// g. Assert: promiseCapability is a PromiseCapability Record.
let PromiseCapability {
promise: _,
resolve,
reject,
} = promise_capability_record;
match handler_result {
// h. If handlerResult is an abrupt completion, then
Err(value) => {
// i. Return ? Call(promiseCapability.[[Reject]], undefined, « handlerResult.[[Value]] »).
reject.call(&JsValue::Undefined, &[value], context)
}
// i. Else,
Ok(value) => {
// i. Return ? Call(promiseCapability.[[Resolve]], undefined, « handlerResult.[[Value]] »).
resolve.call(&JsValue::Undefined, &[value], context)
}
}
}
}
}
},
ReactionJobCaptures { reaction, argument },
},
ReactionJobCaptures { reaction, argument },
),
)
.build()
.into();
@ -121,42 +124,46 @@ impl PromiseJob {
context: &mut Context<'_>,
) -> JobCallback {
// 1. Let job be a new Job Abstract Closure with no parameters that captures promiseToResolve, thenable, and then and performs the following steps when called:
let job = FunctionBuilder::closure_with_captures(
let job = FunctionObjectBuilder::new(
context,
|_this: &JsValue, _args: &[JsValue], captures, context: &mut Context<'_>| {
let JobCapture {
promise_to_resolve,
thenable,
then,
} = captures;
// a. Let resolvingFunctions be CreateResolvingFunctions(promiseToResolve).
let resolving_functions =
Promise::create_resolving_functions(promise_to_resolve, context);
// b. Let thenCallResult be Completion(HostCallJobCallback(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »)).
let then_call_result = then.call_job_callback(
thenable,
&[
resolving_functions.resolve.clone().into(),
resolving_functions.reject.clone().into(),
],
context,
);
// c. If thenCallResult is an abrupt completion, then
if let Err(value) = then_call_result {
let value = value.to_opaque(context);
// i. Return ? Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »).
return resolving_functions
.reject
.call(&JsValue::Undefined, &[value], context);
}
// d. Return ? thenCallResult.
then_call_result
},
JobCapture::new(promise_to_resolve, thenable, then),
NativeFunction::from_copy_closure_with_captures(
|_this: &JsValue, _args: &[JsValue], captures, context: &mut Context<'_>| {
let JobCapture {
promise_to_resolve,
thenable,
then,
} = captures;
// a. Let resolvingFunctions be CreateResolvingFunctions(promiseToResolve).
let resolving_functions =
Promise::create_resolving_functions(promise_to_resolve, context);
// b. Let thenCallResult be Completion(HostCallJobCallback(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »)).
let then_call_result = then.call_job_callback(
thenable,
&[
resolving_functions.resolve.clone().into(),
resolving_functions.reject.clone().into(),
],
context,
);
// c. If thenCallResult is an abrupt completion, then
if let Err(value) = then_call_result {
let value = value.to_opaque(context);
// i. Return ? Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »).
return resolving_functions.reject.call(
&JsValue::Undefined,
&[value],
context,
);
}
// d. Return ? thenCallResult.
then_call_result
},
JobCapture::new(promise_to_resolve, thenable, then),
),
)
.build();

47
boa_engine/src/builtins/proxy/mod.rs

@ -10,10 +10,13 @@
//! [spec]: https://tc39.es/ecma262/#sec-proxy-objects
//! [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
use std::cell::Cell;
use crate::{
builtins::{BuiltIn, JsArgs},
error::JsNativeError,
object::{ConstructorBuilder, FunctionBuilder, JsFunction, JsObject, ObjectData},
native_function::NativeFunction,
object::{ConstructorBuilder, FunctionObjectBuilder, JsFunction, JsObject, ObjectData},
Context, JsResult, JsValue,
};
use boa_gc::{Finalize, Trace};
@ -134,27 +137,29 @@ impl Proxy {
pub(crate) fn revoker(proxy: JsObject, context: &mut Context<'_>) -> JsFunction {
// 3. Let revoker be ! CreateBuiltinFunction(revokerClosure, 0, "", « [[RevocableProxy]] »).
// 4. Set revoker.[[RevocableProxy]] to p.
FunctionBuilder::closure_with_captures(
FunctionObjectBuilder::new(
context,
|_, _, revocable_proxy, _| {
// a. Let F be the active function object.
// b. Let p be F.[[RevocableProxy]].
// d. Set F.[[RevocableProxy]] to null.
if let Some(p) = revocable_proxy.take() {
// e. Assert: p is a Proxy object.
// f. Set p.[[ProxyTarget]] to null.
// g. Set p.[[ProxyHandler]] to null.
p.borrow_mut()
.as_proxy_mut()
.expect("[[RevocableProxy]] must be a proxy object")
.data = None;
}
// c. If p is null, return undefined.
// h. Return undefined.
Ok(JsValue::undefined())
},
Some(proxy),
NativeFunction::from_copy_closure_with_captures(
|_, _, revocable_proxy, _| {
// a. Let F be the active function object.
// b. Let p be F.[[RevocableProxy]].
// d. Set F.[[RevocableProxy]] to null.
if let Some(p) = revocable_proxy.take() {
// e. Assert: p is a Proxy object.
// f. Set p.[[ProxyTarget]] to null.
// g. Set p.[[ProxyHandler]] to null.
p.borrow_mut()
.as_proxy_mut()
.expect("[[RevocableProxy]] must be a proxy object")
.data = None;
}
// c. If p is null, return undefined.
// h. Return undefined.
Ok(JsValue::undefined())
},
Cell::new(Some(proxy)),
),
)
.build()
}

95
boa_engine/src/builtins/regexp/mod.rs

@ -18,9 +18,10 @@ use crate::{
context::intrinsics::StandardConstructors,
error::JsNativeError,
js_string,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::{Attribute, PropertyDescriptorBuilder},
string::{utf16, CodePoint},
@ -53,49 +54,59 @@ impl BuiltIn for RegExp {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let get_species = FunctionBuilder::native(context, Self::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_species =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_species))
.name("get [Symbol.species]")
.constructor(false)
.build();
let flag_attributes = Attribute::CONFIGURABLE | Attribute::NON_ENUMERABLE;
let get_has_indices = FunctionBuilder::native(context, Self::get_has_indices)
.name("get hasIndices")
.constructor(false)
.build();
let get_global = FunctionBuilder::native(context, Self::get_global)
.name("get global")
.constructor(false)
.build();
let get_ignore_case = FunctionBuilder::native(context, Self::get_ignore_case)
.name("get ignoreCase")
.constructor(false)
.build();
let get_multiline = FunctionBuilder::native(context, Self::get_multiline)
.name("get multiline")
.constructor(false)
.build();
let get_dot_all = FunctionBuilder::native(context, Self::get_dot_all)
.name("get dotAll")
.constructor(false)
.build();
let get_unicode = FunctionBuilder::native(context, Self::get_unicode)
.name("get unicode")
.constructor(false)
.build();
let get_sticky = FunctionBuilder::native(context, Self::get_sticky)
.name("get sticky")
.constructor(false)
.build();
let get_flags = FunctionBuilder::native(context, Self::get_flags)
.name("get flags")
.constructor(false)
.build();
let get_source = FunctionBuilder::native(context, Self::get_source)
.name("get source")
.constructor(false)
.build();
let get_has_indices =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_has_indices))
.name("get hasIndices")
.constructor(false)
.build();
let get_global =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_global))
.name("get global")
.constructor(false)
.build();
let get_ignore_case =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_ignore_case))
.name("get ignoreCase")
.constructor(false)
.build();
let get_multiline =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_multiline))
.name("get multiline")
.constructor(false)
.build();
let get_dot_all =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_dot_all))
.name("get dotAll")
.constructor(false)
.build();
let get_unicode =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_unicode))
.name("get unicode")
.constructor(false)
.build();
let get_sticky =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_sticky))
.name("get sticky")
.constructor(false)
.build();
let get_flags =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_flags))
.name("get flags")
.constructor(false)
.build();
let get_source =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_source))
.name("get source")
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,
Self::constructor,

34
boa_engine/src/builtins/set/mod.rs

@ -16,9 +16,10 @@ use crate::{
builtins::BuiltIn,
context::intrinsics::StandardConstructors,
error::JsNativeError,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::{Attribute, PropertyNameKind},
symbol::WellKnownSymbols,
@ -41,25 +42,28 @@ impl BuiltIn for Set {
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let _timer = Profiler::global().start_event(Self::NAME, "init");
let get_species = FunctionBuilder::native(context, Self::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_species =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_species))
.name("get [Symbol.species]")
.constructor(false)
.build();
let size_getter = FunctionBuilder::native(context, Self::size_getter)
.constructor(false)
.name("get size")
.build();
let size_getter =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::size_getter))
.constructor(false)
.name("get size")
.build();
let iterator_symbol = WellKnownSymbols::iterator();
let to_string_tag = WellKnownSymbols::to_string_tag();
let values_function = FunctionBuilder::native(context, Self::values)
.name("values")
.length(0)
.constructor(false)
.build();
let values_function =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::values))
.name("values")
.length(0)
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,

23
boa_engine/src/builtins/symbol/mod.rs

@ -22,7 +22,8 @@ use super::JsArgs;
use crate::{
builtins::BuiltIn,
error::JsNativeError,
object::{ConstructorBuilder, FunctionBuilder},
native_function::NativeFunction,
object::{ConstructorBuilder, FunctionObjectBuilder},
property::Attribute,
symbol::{JsSymbol, WellKnownSymbols},
value::JsValue,
@ -96,16 +97,18 @@ impl BuiltIn for Symbol {
let attribute = Attribute::READONLY | Attribute::NON_ENUMERABLE | Attribute::PERMANENT;
let to_primitive = FunctionBuilder::native(context, Self::to_primitive)
.name("[Symbol.toPrimitive]")
.length(1)
.constructor(false)
.build();
let to_primitive =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::to_primitive))
.name("[Symbol.toPrimitive]")
.length(1)
.constructor(false)
.build();
let get_description = FunctionBuilder::native(context, Self::get_description)
.name("get description")
.constructor(false)
.build();
let get_description =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_description))
.name("get description")
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,

93
boa_engine/src/builtins/typed_array/mod.rs

@ -22,9 +22,10 @@ use crate::{
context::intrinsics::{StandardConstructor, StandardConstructors},
error::JsNativeError,
js_string,
native_function::NativeFunction,
object::{
internal_methods::get_prototype_from_constructor, ConstructorBuilder, FunctionBuilder,
JsObject, ObjectData,
internal_methods::get_prototype_from_constructor, ConstructorBuilder,
FunctionObjectBuilder, JsObject, ObjectData,
},
property::{Attribute, PropertyNameKind},
symbol::WellKnownSymbols,
@ -66,10 +67,13 @@ macro_rules! typed_array {
.typed_array()
.prototype();
let get_species = FunctionBuilder::native(context, TypedArray::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_species = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(TypedArray::get_species),
)
.name("get [Symbol.species]")
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,
@ -250,41 +254,48 @@ pub(crate) struct TypedArray;
impl BuiltIn for TypedArray {
const NAME: &'static str = "TypedArray";
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let get_species = FunctionBuilder::native(context, Self::get_species)
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_buffer = FunctionBuilder::native(context, Self::buffer)
.name("get buffer")
.constructor(false)
.build();
let get_byte_length = FunctionBuilder::native(context, Self::byte_length)
.name("get byteLength")
.constructor(false)
.build();
let get_byte_offset = FunctionBuilder::native(context, Self::byte_offset)
.name("get byteOffset")
.constructor(false)
.build();
let get_length = FunctionBuilder::native(context, Self::length)
.name("get length")
.constructor(false)
.build();
let get_to_string_tag = FunctionBuilder::native(context, Self::to_string_tag)
.name("get [Symbol.toStringTag]")
.constructor(false)
.build();
let values_function = FunctionBuilder::native(context, Self::values)
.name("values")
.length(0)
.constructor(false)
.build();
let get_species =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::get_species))
.name("get [Symbol.species]")
.constructor(false)
.build();
let get_buffer =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::buffer))
.name("get buffer")
.constructor(false)
.build();
let get_byte_length =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::byte_length))
.name("get byteLength")
.constructor(false)
.build();
let get_byte_offset =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::byte_offset))
.name("get byteOffset")
.constructor(false)
.build();
let get_length =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::length))
.name("get length")
.constructor(false)
.build();
let get_to_string_tag =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::to_string_tag))
.name("get [Symbol.toStringTag]")
.constructor(false)
.build();
let values_function =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::values))
.name("values")
.length(0)
.constructor(false)
.build();
ConstructorBuilder::with_standard_constructor(
context,

52
boa_engine/src/builtins/uri/mod.rs

@ -19,8 +19,8 @@ use self::consts::{
use super::BuiltIn;
use crate::{
builtins::JsArgs, js_string, object::FunctionBuilder, property::Attribute, string::CodePoint,
Context, JsNativeError, JsResult, JsString, JsValue,
builtins::JsArgs, js_string, native_function::NativeFunction, object::FunctionObjectBuilder,
property::Attribute, string::CodePoint, Context, JsNativeError, JsResult, JsString, JsValue,
};
/// URI Handling Functions
@ -31,11 +31,12 @@ impl BuiltIn for Uri {
const NAME: &'static str = "Uri";
fn init(context: &mut Context<'_>) -> Option<JsValue> {
let decode_uri = FunctionBuilder::native(context, Self::decode_uri)
.name("decodeURI")
.length(1)
.constructor(false)
.build();
let decode_uri =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::decode_uri))
.name("decodeURI")
.length(1)
.constructor(false)
.build();
context.register_global_property(
"decodeURI",
@ -43,11 +44,14 @@ impl BuiltIn for Uri {
Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
);
let decode_uri_component = FunctionBuilder::native(context, Self::decode_uri_component)
.name("decodeURIComponent")
.length(1)
.constructor(false)
.build();
let decode_uri_component = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(Self::decode_uri_component),
)
.name("decodeURIComponent")
.length(1)
.constructor(false)
.build();
context.register_global_property(
"decodeURIComponent",
@ -55,11 +59,12 @@ impl BuiltIn for Uri {
Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
);
let encode_uri = FunctionBuilder::native(context, Self::encode_uri)
.name("encodeURI")
.length(1)
.constructor(false)
.build();
let encode_uri =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(Self::encode_uri))
.name("encodeURI")
.length(1)
.constructor(false)
.build();
context.register_global_property(
"encodeURI",
@ -67,11 +72,14 @@ impl BuiltIn for Uri {
Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
);
let encode_uri_component = FunctionBuilder::native(context, Self::encode_uri_component)
.name("encodeURIComponent")
.length(1)
.constructor(false)
.build();
let encode_uri_component = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(Self::encode_uri_component),
)
.name("encodeURIComponent")
.length(1)
.constructor(false)
.build();
context.register_global_property(
"encodeURIComponent",

6
boa_engine/src/class.rs

@ -62,8 +62,8 @@
//! [class-trait]: ./trait.Class.html
use crate::{
builtins::function::NativeFunctionSignature,
error::JsNativeError,
native_function::NativeFunctionPointer,
object::{ConstructorBuilder, JsFunction, JsObject, NativeObject, ObjectData, PROTOTYPE},
property::{Attribute, PropertyDescriptor, PropertyKey},
Context, JsResult, JsValue,
@ -183,7 +183,7 @@ impl<'ctx, 'icu> ClassBuilder<'ctx, 'icu> {
&mut self,
name: N,
length: usize,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
) -> &mut Self
where
N: AsRef<str>,
@ -199,7 +199,7 @@ impl<'ctx, 'icu> ClassBuilder<'ctx, 'icu> {
&mut self,
name: N,
length: usize,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
) -> &mut Self
where
N: AsRef<str>,

85
boa_engine/src/context/mod.rs

@ -17,11 +17,12 @@ pub use std::marker::PhantomData;
#[cfg(feature = "console")]
use crate::builtins::console::Console;
use crate::{
builtins::{self, function::NativeFunctionSignature},
builtins,
bytecompiler::ByteCompiler,
class::{Class, ClassBuilder},
job::JobCallback,
object::{FunctionBuilder, GlobalPropertyMap, JsObject},
native_function::NativeFunction,
object::{FunctionObjectBuilder, GlobalPropertyMap, JsObject},
property::{Attribute, PropertyDescriptor, PropertyKey},
realm::Realm,
vm::{CallFrame, CodeBlock, FinallyReturn, GeneratorResumeKind, Vm},
@ -268,10 +269,7 @@ impl Context<'_> {
);
}
/// Register a global native function.
///
/// This is more efficient that creating a closure function, since this does not allocate,
/// it is just a function pointer.
/// Register a global native callable.
///
/// The function will be both `constructable` (call with `new <name>()`) and `callable` (call
/// with `<name>()`).
@ -281,18 +279,10 @@ impl Context<'_> {
///
/// # Note
///
/// If you want to make a function only `constructable`, or wish to bind it differently
/// to the global object, you can create the function object with
/// [`FunctionBuilder`](crate::object::FunctionBuilder::native). And bind it to the global
/// object with [`Context::register_global_property`](Context::register_global_property)
/// method.
pub fn register_global_function(
&mut self,
name: &str,
length: usize,
body: NativeFunctionSignature,
) {
let function = FunctionBuilder::native(self, body)
/// If you wish to only create the function object without binding it to the global object, you
/// can use the [`FunctionObjectBuilder`] API.
pub fn register_global_callable(&mut self, name: &str, length: usize, body: NativeFunction) {
let function = FunctionObjectBuilder::new(self, body)
.name(name)
.length(length)
.constructor(true)
@ -311,24 +301,20 @@ impl Context<'_> {
/// Register a global native function that is not a constructor.
///
/// This is more efficient that creating a closure function, since this does not allocate,
/// it is just a function pointer.
///
/// The function will be bound to the global object with `writable`, `non-enumerable`
/// and `configurable` attributes. The same as when you create a function in JavaScript.
///
/// # Note
///
/// The difference to [`Context::register_global_function`](Context::register_global_function) is,
/// that the function will not be `constructable`.
/// Usage of the function as a constructor will produce a `TypeError`.
pub fn register_global_builtin_function(
/// The difference to [`Context::register_global_callable`] is, that the function will not be
/// `constructable`. Usage of the function as a constructor will produce a `TypeError`.
pub fn register_global_builtin_callable(
&mut self,
name: &str,
length: usize,
body: NativeFunctionSignature,
body: NativeFunction,
) {
let function = FunctionBuilder::native(self, body)
let function = FunctionObjectBuilder::new(self, body)
.name(name)
.length(length)
.constructor(false)
@ -345,51 +331,6 @@ impl Context<'_> {
);
}
/// Register a global closure function.
///
/// The function will be both `constructable` (call with `new`).
///
/// The function will be bound to the global object with `writable`, `non-enumerable`
/// and `configurable` attributes. The same as when you create a function in JavaScript.
///
/// # Note #1
///
/// If you want to make a function only `constructable`, or wish to bind it differently
/// to the global object, you can create the function object with
/// [`FunctionBuilder`](crate::object::FunctionBuilder::closure). And bind it to the global
/// object with [`Context::register_global_property`](Context::register_global_property)
/// method.
///
/// # Note #2
///
/// This function will only accept `Copy` closures, meaning you cannot
/// move `Clone` types, just `Copy` types. If you need to move `Clone` types
/// as captures, see [`FunctionBuilder::closure_with_captures`].
///
/// See <https://github.com/boa-dev/boa/issues/1515> for an explanation on
/// why we need to restrict the set of accepted closures.
pub fn register_global_closure<F>(&mut self, name: &str, length: usize, body: F) -> JsResult<()>
where
F: Fn(&JsValue, &[JsValue], &mut Context<'_>) -> JsResult<JsValue> + Copy + 'static,
{
let function = FunctionBuilder::closure(self, body)
.name(name)
.length(length)
.constructor(true)
.build();
self.global_bindings_mut().insert(
name.into(),
PropertyDescriptor::builder()
.value(function)
.writable(true)
.enumerable(false)
.configurable(true)
.build(),
);
Ok(())
}
/// Register a global class of type `T`, where `T` implements `Class`.
///
/// # Example

1
boa_engine/src/lib.rs

@ -115,6 +115,7 @@ pub mod context;
pub mod environments;
pub mod error;
pub mod job;
pub mod native_function;
pub mod object;
pub mod property;
pub mod realm;

365
boa_engine/src/native_function.rs

@ -0,0 +1,365 @@
//! Boa's wrappers for native Rust functions to be compatible with ECMAScript calls.
//!
//! [`NativeFunction`] is the main type of this module, providing APIs to create native callables
//! from native Rust functions and closures.
use std::marker::PhantomData;
use boa_gc::{custom_trace, Finalize, Gc, Trace};
use crate::{Context, JsResult, JsValue};
/// The required signature for all native built-in function pointers.
///
/// # Arguments
///
/// - The first argument represents the `this` variable of every ECMAScript function.
///
/// - The second argument represents the list of all arguments passed to the function.
///
/// - The last argument is the engine [`Context`].
pub type NativeFunctionPointer = fn(&JsValue, &[JsValue], &mut Context<'_>) -> JsResult<JsValue>;
trait TraceableClosure: Trace {
fn call(
&self,
this: &JsValue,
args: &[JsValue],
context: &mut Context<'_>,
) -> JsResult<JsValue>;
}
#[derive(Trace, Finalize)]
struct Closure<F, T>
where
F: Fn(&JsValue, &[JsValue], &T, &mut Context<'_>) -> JsResult<JsValue>,
T: Trace,
{
// SAFETY: `NativeFunction`'s safe API ensures only `Copy` closures are stored; its unsafe API,
// on the other hand, explains the invariants to hold in order for this to be safe, shifting
// the responsibility to the caller.
#[unsafe_ignore_trace]
f: F,
captures: T,
}
impl<F, T> TraceableClosure for Closure<F, T>
where
F: Fn(&JsValue, &[JsValue], &T, &mut Context<'_>) -> JsResult<JsValue>,
T: Trace,
{
fn call(
&self,
this: &JsValue,
args: &[JsValue],
context: &mut Context<'_>,
) -> JsResult<JsValue> {
(self.f)(this, args, &self.captures, context)
}
}
/// A callable Rust function that can be invoked by the engine.
///
/// `NativeFunction` functions are divided in two:
/// - Function pointers a.k.a common functions (see [`NativeFunctionPointer`]).
/// - Closure functions that can capture the current environment.
///
/// # Caveats
///
/// By limitations of the Rust language, the garbage collector currently cannot inspect closures
/// in order to trace their captured variables. This means that only [`Copy`] closures are 100% safe
/// to use. All other closures can also be stored in a `NativeFunction`, albeit by using an `unsafe`
/// API, but note that passing closures implicitly capturing traceable types could cause
/// **Undefined Behaviour**.
#[derive(Clone)]
pub struct NativeFunction {
inner: Inner,
}
#[derive(Clone)]
enum Inner {
PointerFn(NativeFunctionPointer),
Closure(Gc<dyn TraceableClosure>),
}
impl Finalize for NativeFunction {
fn finalize(&self) {
if let Inner::Closure(c) = &self.inner {
c.finalize();
}
}
}
// Manual implementation because deriving `Trace` triggers the `single_use_lifetimes` lint.
// SAFETY: Only closures can contain `Trace` captures, so this implementation is safe.
unsafe impl Trace for NativeFunction {
custom_trace!(this, {
if let Inner::Closure(c) = &this.inner {
mark(c);
}
});
}
impl std::fmt::Debug for NativeFunction {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NativeFunction").finish_non_exhaustive()
}
}
impl NativeFunction {
/// Creates a `NativeFunction` from a function pointer.
#[inline]
pub fn from_fn_ptr(function: NativeFunctionPointer) -> Self {
Self {
inner: Inner::PointerFn(function),
}
}
/// Creates a `NativeFunction` from a `Copy` closure.
pub fn from_copy_closure<F>(closure: F) -> Self
where
F: Fn(&JsValue, &[JsValue], &mut Context<'_>) -> JsResult<JsValue> + Copy + 'static,
{
// SAFETY: The `Copy` bound ensures there are no traceable types inside the closure.
unsafe { Self::from_closure(closure) }
}
/// Creates a `NativeFunction` from a `Copy` closure and a list of traceable captures.
pub fn from_copy_closure_with_captures<F, T>(closure: F, captures: T) -> Self
where
F: Fn(&JsValue, &[JsValue], &T, &mut Context<'_>) -> JsResult<JsValue> + Copy + 'static,
T: Trace + 'static,
{
// SAFETY: The `Copy` bound ensures there are no traceable types inside the closure.
unsafe { Self::from_closure_with_captures(closure, captures) }
}
/// Creates a new `NativeFunction` from a closure.
///
/// # Safety
///
/// Passing a closure that contains a captured variable that needs to be traced by the garbage
/// collector could cause an use after free, memory corruption or other kinds of **Undefined
/// Behaviour**. See <https://github.com/Manishearth/rust-gc/issues/50> for a technical explanation
/// on why that is the case.
pub unsafe fn from_closure<F>(closure: F) -> Self
where
F: Fn(&JsValue, &[JsValue], &mut Context<'_>) -> JsResult<JsValue> + 'static,
{
// SAFETY: The caller must ensure the invariants of the closure hold.
unsafe {
Self::from_closure_with_captures(
move |this, args, _, context| closure(this, args, context),
(),
)
}
}
/// Create a new `NativeFunction` from a closure and a list of traceable captures.
///
/// # Safety
///
/// Passing a closure that contains a captured variable that needs to be traced by the garbage
/// collector could cause an use after free, memory corruption or other kinds of **Undefined
/// Behaviour**. See <https://github.com/Manishearth/rust-gc/issues/50> for a technical explanation
/// on why that is the case.
pub unsafe fn from_closure_with_captures<F, T>(closure: F, captures: T) -> Self
where
F: Fn(&JsValue, &[JsValue], &T, &mut Context<'_>) -> JsResult<JsValue> + 'static,
T: Trace + 'static,
{
// Hopefully, this unsafe operation will be replaced by the `CoerceUnsized` API in the
// future: https://github.com/rust-lang/rust/issues/18598
let ptr = Gc::into_raw(Gc::new(Closure {
f: closure,
captures,
}));
// SAFETY: The pointer returned by `into_raw` is only used to coerce to a trait object,
// meaning this is safe.
unsafe {
Self {
inner: Inner::Closure(Gc::from_raw(ptr)),
}
}
}
/// Calls this `NativeFunction`, forwarding the arguments to the corresponding function.
#[inline]
pub fn call(
&self,
this: &JsValue,
args: &[JsValue],
context: &mut Context<'_>,
) -> JsResult<JsValue> {
match self.inner {
Inner::PointerFn(f) => f(this, args, context),
Inner::Closure(ref c) => c.call(this, args, context),
}
}
}
trait TraceableGenericClosure<Ret, Args>: Trace {
fn call(&mut self, args: Args, context: &mut Context<'_>) -> Ret;
}
#[derive(Trace, Finalize)]
struct GenericClosure<Ret, Args, F, T>
where
F: FnMut(Args, &mut T, &mut Context<'_>) -> Ret,
T: Trace,
{
// SAFETY: `GenericNativeFunction`'s safe API ensures only `Copy` closures are stored; its unsafe API,
// on the other hand, explains the invariants to hold in order for this to be safe, shifting
// the responsibility to the caller.
#[unsafe_ignore_trace]
f: F,
captures: T,
#[allow(clippy::type_complexity)]
phantom: PhantomData<Box<dyn FnMut(Args, &mut T, &mut Context<'_>) -> Ret>>,
}
impl<Ret, Args, F, T> TraceableGenericClosure<Ret, Args> for GenericClosure<Ret, Args, F, T>
where
F: FnMut(Args, &mut T, &mut Context<'_>) -> Ret,
T: Trace,
{
fn call(&mut self, args: Args, context: &mut Context<'_>) -> Ret {
(self.f)(args, &mut self.captures, context)
}
}
/// A callable generic Rust function that can be invoked by the engine.
///
/// This is a more general struct of the [`NativeFunction`] API, useful for callbacks defined in the
/// host that are useful to the engine, such as [`HostCallJobCallback`] or [`HostEnqueuePromiseJob`].
///
/// `GenericNativeFunction` functions are divided in two:
/// - Function pointers a.k.a common functions.
/// - Closure functions that can capture the current environment.
///
/// # Caveats
///
/// - Since the Rust language doesn't support [**variadic generics**], all functions requiring
/// more than 1 argument (excluding the required [`Context`]), will define its generic parameter
/// `Args` as a tuple instead, which slightly worsens the API. We hope this can improve when
/// variadic generics arrive.
///
/// - By limitations of the Rust language, the garbage collector currently cannot inspect closures
/// in order to trace their captured variables. This means that only [`Copy`] closures are 100% safe
/// to use. All other closures can also be stored in a `GenericNativeFunction`, albeit by using an
/// `unsafe` API, but note that passing closures implicitly capturing traceable types could cause
/// **Undefined Behaviour**.
///
/// [`HostCallJobCallback`]: https://tc39.es/ecma262/#sec-hostcalljobcallback
/// [`HostEnqueuePromiseJob`]: https://tc39.es/ecma262/#sec-hostenqueuepromisejob
/// [**variadic generics**]: https://github.com/rust-lang/rfcs/issues/376
pub struct GenericNativeFunction<Ret: 'static, Args: 'static> {
inner: GenericInner<Ret, Args>,
}
enum GenericInner<Ret: 'static, Args: 'static> {
PointerFn(fn(Args, &mut Context<'_>) -> Ret),
Closure(Box<dyn TraceableGenericClosure<Ret, Args>>),
}
impl<Ret, Args> Finalize for GenericNativeFunction<Ret, Args> {
fn finalize(&self) {
if let GenericInner::Closure(c) = &self.inner {
c.finalize();
}
}
}
// Manual implementation because deriving `Trace` triggers the `single_use_lifetimes` lint.
// SAFETY: Only closures can contain `Trace` captures, so this implementation is safe.
unsafe impl<Ret, Args> Trace for GenericNativeFunction<Ret, Args> {
custom_trace!(this, {
if let GenericInner::Closure(c) = &this.inner {
mark(c);
}
});
}
impl<Ret, Args> std::fmt::Debug for GenericNativeFunction<Ret, Args> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NativeFunction").finish_non_exhaustive()
}
}
impl<Ret, Args> GenericNativeFunction<Ret, Args> {
/// Creates a `GenericNativeFunction` from a function pointer.
#[inline]
pub fn from_fn_ptr(function: fn(Args, &mut Context<'_>) -> Ret) -> Self {
Self {
inner: GenericInner::PointerFn(function),
}
}
/// Creates a `GenericNativeFunction` from a `Copy` closure.
pub fn from_copy_closure<F>(closure: F) -> Self
where
F: FnMut(Args, &mut Context<'_>) -> Ret + Copy + 'static,
{
// SAFETY: The `Copy` bound ensures there are no traceable types inside the closure.
unsafe { Self::from_closure(closure) }
}
/// Creates a `GenericNativeFunction` from a `Copy` closure and a list of traceable captures.
pub fn from_copy_closure_with_captures<F, T>(closure: F, captures: T) -> Self
where
F: FnMut(Args, &mut T, &mut Context<'_>) -> Ret + Copy + 'static,
T: Trace + 'static,
{
// SAFETY: The `Copy` bound ensures there are no traceable types inside the closure.
unsafe { Self::from_closure_with_captures(closure, captures) }
}
/// Creates a new `GenericNativeFunction` from a closure.
///
/// # Safety
///
/// Passing a closure that contains a captured variable that needs to be traced by the garbage
/// collector could cause an use after free, memory corruption or other kinds of **Undefined
/// Behaviour**. See <https://github.com/Manishearth/rust-gc/issues/50> for a technical explanation
/// on why that is the case.
pub unsafe fn from_closure<F>(mut closure: F) -> Self
where
F: FnMut(Args, &mut Context<'_>) -> Ret + 'static,
{
// SAFETY: The caller must ensure the invariants of the closure hold.
unsafe {
Self::from_closure_with_captures(move |args, _, context| closure(args, context), ())
}
}
/// Create a new `GenericNativeFunction` from a closure and a list of traceable captures.
///
/// # Safety
///
/// Passing a closure that contains a captured variable that needs to be traced by the garbage
/// collector could cause an use after free, memory corruption or other kinds of **Undefined
/// Behaviour**. See <https://github.com/Manishearth/rust-gc/issues/50> for a technical explanation
/// on why that is the case.
pub unsafe fn from_closure_with_captures<F, T>(closure: F, captures: T) -> Self
where
F: FnMut(Args, &mut T, &mut Context<'_>) -> Ret + 'static,
T: Trace + 'static,
{
Self {
inner: GenericInner::Closure(Box::new(GenericClosure {
f: closure,
captures,
phantom: PhantomData,
})),
}
}
/// Calls this `GenericNativeFunction`, forwarding the arguments to the corresponding function.
#[inline]
pub fn call(&mut self, args: Args, context: &mut Context<'_>) -> Ret {
match self.inner {
GenericInner::PointerFn(f) => f(args, context),
GenericInner::Closure(ref mut c) => c.call(args, context),
}
}
}

127
boa_engine/src/object/builtins/jsproxy.rs

@ -2,8 +2,9 @@
use boa_gc::{Finalize, Trace};
use crate::{
builtins::{function::NativeFunctionSignature, Proxy},
object::{FunctionBuilder, JsObject, JsObjectType, ObjectData},
builtins::Proxy,
native_function::{NativeFunction, NativeFunctionPointer},
object::{FunctionObjectBuilder, JsObject, JsObjectType, ObjectData},
Context, JsResult, JsValue,
};
@ -104,19 +105,19 @@ impl std::ops::Deref for JsRevocableProxy {
#[derive(Clone)]
pub struct JsProxyBuilder {
target: JsObject,
apply: Option<NativeFunctionSignature>,
construct: Option<NativeFunctionSignature>,
define_property: Option<NativeFunctionSignature>,
delete_property: Option<NativeFunctionSignature>,
get: Option<NativeFunctionSignature>,
get_own_property_descriptor: Option<NativeFunctionSignature>,
get_prototype_of: Option<NativeFunctionSignature>,
has: Option<NativeFunctionSignature>,
is_extensible: Option<NativeFunctionSignature>,
own_keys: Option<NativeFunctionSignature>,
prevent_extensions: Option<NativeFunctionSignature>,
set: Option<NativeFunctionSignature>,
set_prototype_of: Option<NativeFunctionSignature>,
apply: Option<NativeFunctionPointer>,
construct: Option<NativeFunctionPointer>,
define_property: Option<NativeFunctionPointer>,
delete_property: Option<NativeFunctionPointer>,
get: Option<NativeFunctionPointer>,
get_own_property_descriptor: Option<NativeFunctionPointer>,
get_prototype_of: Option<NativeFunctionPointer>,
has: Option<NativeFunctionPointer>,
is_extensible: Option<NativeFunctionPointer>,
own_keys: Option<NativeFunctionPointer>,
prevent_extensions: Option<NativeFunctionPointer>,
set: Option<NativeFunctionPointer>,
set_prototype_of: Option<NativeFunctionPointer>,
}
impl std::fmt::Debug for JsProxyBuilder {
@ -195,7 +196,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/apply
#[inline]
pub fn apply(mut self, apply: NativeFunctionSignature) -> Self {
pub fn apply(mut self, apply: NativeFunctionPointer) -> Self {
self.apply = Some(apply);
self
}
@ -213,7 +214,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/construct
#[inline]
pub fn construct(mut self, construct: NativeFunctionSignature) -> Self {
pub fn construct(mut self, construct: NativeFunctionPointer) -> Self {
self.construct = Some(construct);
self
}
@ -226,7 +227,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/defineProperty
#[inline]
pub fn define_property(mut self, define_property: NativeFunctionSignature) -> Self {
pub fn define_property(mut self, define_property: NativeFunctionPointer) -> Self {
self.define_property = Some(define_property);
self
}
@ -239,7 +240,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/deleteProperty
#[inline]
pub fn delete_property(mut self, delete_property: NativeFunctionSignature) -> Self {
pub fn delete_property(mut self, delete_property: NativeFunctionPointer) -> Self {
self.delete_property = Some(delete_property);
self
}
@ -252,7 +253,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get
#[inline]
pub fn get(mut self, get: NativeFunctionSignature) -> Self {
pub fn get(mut self, get: NativeFunctionPointer) -> Self {
self.get = Some(get);
self
}
@ -267,7 +268,7 @@ impl JsProxyBuilder {
#[inline]
pub fn get_own_property_descriptor(
mut self,
get_own_property_descriptor: NativeFunctionSignature,
get_own_property_descriptor: NativeFunctionPointer,
) -> Self {
self.get_own_property_descriptor = Some(get_own_property_descriptor);
self
@ -281,7 +282,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/getPrototypeOf
#[inline]
pub fn get_prototype_of(mut self, get_prototype_of: NativeFunctionSignature) -> Self {
pub fn get_prototype_of(mut self, get_prototype_of: NativeFunctionPointer) -> Self {
self.get_prototype_of = Some(get_prototype_of);
self
}
@ -294,7 +295,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/has
#[inline]
pub fn has(mut self, has: NativeFunctionSignature) -> Self {
pub fn has(mut self, has: NativeFunctionPointer) -> Self {
self.has = Some(has);
self
}
@ -307,7 +308,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/isExtensible
#[inline]
pub fn is_extensible(mut self, is_extensible: NativeFunctionSignature) -> Self {
pub fn is_extensible(mut self, is_extensible: NativeFunctionPointer) -> Self {
self.is_extensible = Some(is_extensible);
self
}
@ -320,7 +321,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/ownKeys
#[inline]
pub fn own_keys(mut self, own_keys: NativeFunctionSignature) -> Self {
pub fn own_keys(mut self, own_keys: NativeFunctionPointer) -> Self {
self.own_keys = Some(own_keys);
self
}
@ -333,7 +334,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/preventExtensions
#[inline]
pub fn prevent_extensions(mut self, prevent_extensions: NativeFunctionSignature) -> Self {
pub fn prevent_extensions(mut self, prevent_extensions: NativeFunctionPointer) -> Self {
self.prevent_extensions = Some(prevent_extensions);
self
}
@ -346,7 +347,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/set
#[inline]
pub fn set(mut self, set: NativeFunctionSignature) -> Self {
pub fn set(mut self, set: NativeFunctionPointer) -> Self {
self.set = Some(set);
self
}
@ -359,7 +360,7 @@ impl JsProxyBuilder {
///
/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/setPrototypeOf
#[inline]
pub fn set_prototype_of(mut self, set_prototype_of: NativeFunctionSignature) -> Self {
pub fn set_prototype_of(mut self, set_prototype_of: NativeFunctionPointer) -> Self {
self.set_prototype_of = Some(set_prototype_of);
self
}
@ -374,13 +375,15 @@ impl JsProxyBuilder {
let handler = JsObject::with_object_proto(context);
if let Some(apply) = self.apply {
let f = FunctionBuilder::native(context, apply).length(3).build();
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(apply))
.length(3)
.build();
handler
.create_data_property_or_throw("apply", f, context)
.expect("new object should be writable");
}
if let Some(construct) = self.construct {
let f = FunctionBuilder::native(context, construct)
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(construct))
.length(3)
.build();
handler
@ -388,51 +391,61 @@ impl JsProxyBuilder {
.expect("new object should be writable");
}
if let Some(define_property) = self.define_property {
let f = FunctionBuilder::native(context, define_property)
.length(3)
.build();
let f =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(define_property))
.length(3)
.build();
handler
.create_data_property_or_throw("defineProperty", f, context)
.expect("new object should be writable");
}
if let Some(delete_property) = self.delete_property {
let f = FunctionBuilder::native(context, delete_property)
.length(2)
.build();
let f =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(delete_property))
.length(2)
.build();
handler
.create_data_property_or_throw("deleteProperty", f, context)
.expect("new object should be writable");
}
if let Some(get) = self.get {
let f = FunctionBuilder::native(context, get).length(3).build();
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(get))
.length(3)
.build();
handler
.create_data_property_or_throw("get", f, context)
.expect("new object should be writable");
}
if let Some(get_own_property_descriptor) = self.get_own_property_descriptor {
let f = FunctionBuilder::native(context, get_own_property_descriptor)
.length(2)
.build();
let f = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(get_own_property_descriptor),
)
.length(2)
.build();
handler
.create_data_property_or_throw("getOwnPropertyDescriptor", f, context)
.expect("new object should be writable");
}
if let Some(get_prototype_of) = self.get_prototype_of {
let f = FunctionBuilder::native(context, get_prototype_of)
.length(1)
.build();
let f =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(get_prototype_of))
.length(1)
.build();
handler
.create_data_property_or_throw("getPrototypeOf", f, context)
.expect("new object should be writable");
}
if let Some(has) = self.has {
let f = FunctionBuilder::native(context, has).length(2).build();
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(has))
.length(2)
.build();
handler
.create_data_property_or_throw("has", f, context)
.expect("new object should be writable");
}
if let Some(is_extensible) = self.is_extensible {
let f = FunctionBuilder::native(context, is_extensible)
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(is_extensible))
.length(1)
.build();
handler
@ -440,29 +453,37 @@ impl JsProxyBuilder {
.expect("new object should be writable");
}
if let Some(own_keys) = self.own_keys {
let f = FunctionBuilder::native(context, own_keys).length(1).build();
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(own_keys))
.length(1)
.build();
handler
.create_data_property_or_throw("ownKeys", f, context)
.expect("new object should be writable");
}
if let Some(prevent_extensions) = self.prevent_extensions {
let f = FunctionBuilder::native(context, prevent_extensions)
.length(1)
.build();
let f = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(prevent_extensions),
)
.length(1)
.build();
handler
.create_data_property_or_throw("preventExtensions", f, context)
.expect("new object should be writable");
}
if let Some(set) = self.set {
let f = FunctionBuilder::native(context, set).length(4).build();
let f = FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(set))
.length(4)
.build();
handler
.create_data_property_or_throw("set", f, context)
.expect("new object should be writable");
}
if let Some(set_prototype_of) = self.set_prototype_of {
let f = FunctionBuilder::native(context, set_prototype_of)
.length(2)
.build();
let f =
FunctionObjectBuilder::new(context, NativeFunction::from_fn_ptr(set_prototype_of))
.length(2)
.build();
handler
.create_data_property_or_throw("setPrototypeOf", f, context)
.expect("new object should be writable");

117
boa_engine/src/object/mod.rs

@ -33,10 +33,7 @@ use crate::{
async_generator::AsyncGenerator,
error::ErrorKind,
function::arguments::Arguments,
function::{
arguments::ParameterMap, BoundFunction, Captures, ConstructorKind, Function,
NativeFunctionSignature,
},
function::{arguments::ParameterMap, BoundFunction, ConstructorKind, Function},
generator::Generator,
iterable::AsyncFromSyncIterator,
map::map_iterator::MapIterator,
@ -51,10 +48,10 @@ use crate::{
DataView, Date, Promise, RegExp,
},
context::intrinsics::StandardConstructor,
error::JsNativeError,
js_string,
native_function::{NativeFunction, NativeFunctionPointer},
property::{Attribute, PropertyDescriptor, PropertyKey},
Context, JsBigInt, JsResult, JsString, JsSymbol, JsValue,
Context, JsBigInt, JsString, JsSymbol, JsValue,
};
use boa_gc::{custom_trace, Finalize, GcCell, Trace, WeakGc};
@ -1899,17 +1896,17 @@ where
/// Builder for creating native function objects
#[derive(Debug)]
pub struct FunctionBuilder<'ctx, 'icu> {
pub struct FunctionObjectBuilder<'ctx, 'icu> {
context: &'ctx mut Context<'icu>,
function: Function,
name: JsString,
length: usize,
}
impl<'ctx, 'icu> FunctionBuilder<'ctx, 'icu> {
impl<'ctx, 'icu> FunctionObjectBuilder<'ctx, 'icu> {
/// Create a new `FunctionBuilder` for creating a native function.
#[inline]
pub fn native(context: &'ctx mut Context<'icu>, function: NativeFunctionSignature) -> Self {
pub fn new(context: &'ctx mut Context<'icu>, function: NativeFunction) -> Self {
Self {
context,
function: Function::Native {
@ -1921,57 +1918,6 @@ impl<'ctx, 'icu> FunctionBuilder<'ctx, 'icu> {
}
}
/// Create a new `FunctionBuilder` for creating a closure function.
pub fn closure<F>(context: &'ctx mut Context<'icu>, function: F) -> Self
where
F: Fn(&JsValue, &[JsValue], &mut Context<'_>) -> JsResult<JsValue> + Copy + 'static,
{
Self {
context,
function: Function::Closure {
function: Box::new(move |this, args, _, context| function(this, args, context)),
constructor: None,
captures: Captures::new(()),
},
name: js_string!(),
length: 0,
}
}
/// Create a new closure function with additional captures.
///
/// # Note
///
/// You can only move variables that implement `Debug + Any + Trace + Clone`.
/// In other words, only `NativeObject + Clone` objects are movable.
pub fn closure_with_captures<F, C>(
context: &'ctx mut Context<'icu>,
function: F,
captures: C,
) -> Self
where
F: Fn(&JsValue, &[JsValue], &mut C, &mut Context<'_>) -> JsResult<JsValue> + Copy + 'static,
C: NativeObject,
{
Self {
context,
function: Function::Closure {
function: Box::new(move |this, args, captures: Captures, context| {
let mut captures = captures.as_mut_any();
let captures = captures.downcast_mut::<C>().ok_or_else(|| {
JsNativeError::typ()
.with_message("cannot downcast `Captures` to given type")
})?;
function(this, args, captures, context)
}),
constructor: None,
captures: Captures::new(captures),
},
name: js_string!(),
length: 0,
}
}
/// Specify the name property of object function object.
///
/// The default is `""` (empty string).
@ -2005,10 +1951,6 @@ impl<'ctx, 'icu> FunctionBuilder<'ctx, 'icu> {
Function::Native {
ref mut constructor,
..
}
| Function::Closure {
ref mut constructor,
..
} => {
*constructor = yes.then_some(ConstructorKind::Base);
}
@ -2102,7 +2044,7 @@ impl<'ctx, 'icu> ObjectInitializer<'ctx, 'icu> {
/// Add a function to the object.
pub fn function<B>(
&mut self,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
binding: B,
length: usize,
) -> &mut Self
@ -2110,11 +2052,12 @@ impl<'ctx, 'icu> ObjectInitializer<'ctx, 'icu> {
B: Into<FunctionBinding>,
{
let binding = binding.into();
let function = FunctionBuilder::native(self.context, function)
.name(binding.name)
.length(length)
.constructor(false)
.build();
let function =
FunctionObjectBuilder::new(self.context, NativeFunction::from_fn_ptr(function))
.name(binding.name)
.length(length)
.constructor(false)
.build();
self.object.borrow_mut().insert(
binding.binding,
@ -2152,7 +2095,7 @@ impl<'ctx, 'icu> ObjectInitializer<'ctx, 'icu> {
/// Builder for creating constructors objects, like `Array`.
pub struct ConstructorBuilder<'ctx, 'icu> {
context: &'ctx mut Context<'icu>,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
object: JsObject,
has_prototype_property: bool,
prototype: JsObject,
@ -2184,7 +2127,7 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
#[inline]
pub fn new(
context: &'ctx mut Context<'icu>,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
) -> ConstructorBuilder<'ctx, 'icu> {
Self {
context,
@ -2203,7 +2146,7 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
pub(crate) fn with_standard_constructor(
context: &'ctx mut Context<'icu>,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
standard_constructor: StandardConstructor,
) -> ConstructorBuilder<'ctx, 'icu> {
Self {
@ -2224,7 +2167,7 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
/// Add new method to the constructors prototype.
pub fn method<B>(
&mut self,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
binding: B,
length: usize,
) -> &mut Self
@ -2232,11 +2175,12 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
B: Into<FunctionBinding>,
{
let binding = binding.into();
let function = FunctionBuilder::native(self.context, function)
.name(binding.name)
.length(length)
.constructor(false)
.build();
let function =
FunctionObjectBuilder::new(self.context, NativeFunction::from_fn_ptr(function))
.name(binding.name)
.length(length)
.constructor(false)
.build();
self.prototype.borrow_mut().insert(
binding.binding,
@ -2252,7 +2196,7 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
/// Add new static method to the constructors object itself.
pub fn static_method<B>(
&mut self,
function: NativeFunctionSignature,
function: NativeFunctionPointer,
binding: B,
length: usize,
) -> &mut Self
@ -2260,11 +2204,12 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
B: Into<FunctionBinding>,
{
let binding = binding.into();
let function = FunctionBuilder::native(self.context, function)
.name(binding.name)
.length(length)
.constructor(false)
.build();
let function =
FunctionObjectBuilder::new(self.context, NativeFunction::from_fn_ptr(function))
.name(binding.name)
.length(length)
.constructor(false)
.build();
self.object.borrow_mut().insert(
binding.binding,
@ -2443,7 +2388,7 @@ impl<'ctx, 'icu> ConstructorBuilder<'ctx, 'icu> {
pub fn build(&mut self) -> JsFunction {
// Create the native function
let function = Function::Native {
function: self.function,
function: NativeFunction::from_fn_ptr(self.function),
constructor: self.constructor,
};

45
boa_engine/src/vm/code_block.rs

@ -705,25 +705,16 @@ impl JsObject {
function,
constructor,
} => {
let function = *function;
let function = function.clone();
let constructor = *constructor;
drop(object);
if constructor.is_some() {
function(&JsValue::undefined(), args, context)
function.call(&JsValue::undefined(), args, context)
} else {
function(this, args, context)
function.call(this, args, context)
}
}
Function::Closure {
function, captures, ..
} => {
let function = function.clone();
let captures = captures.clone();
drop(object);
(function)(this, args, captures, context)
}
Function::Ordinary {
code, environments, ..
} => {
@ -1288,41 +1279,15 @@ impl JsObject {
function,
constructor,
..
} => {
let function = *function;
let constructor = *constructor;
drop(object);
match function(this_target, args, context)? {
JsValue::Object(ref o) => Ok(o.clone()),
val => {
if constructor.expect("hmm").is_base() || val.is_undefined() {
create_this(context)
} else {
Err(JsNativeError::typ()
.with_message(
"Derived constructor can only return an Object or undefined",
)
.into())
}
}
}
}
Function::Closure {
function,
captures,
constructor,
..
} => {
let function = function.clone();
let captures = captures.clone();
let constructor = *constructor;
drop(object);
match (function)(this_target, args, captures, context)? {
match function.call(this_target, args, context)? {
JsValue::Object(ref o) => Ok(o.clone()),
val => {
if constructor.expect("hmma").is_base() || val.is_undefined() {
if constructor.expect("hmm").is_base() || val.is_undefined() {
create_this(context)
} else {
Err(JsNativeError::typ()

133
boa_engine/src/vm/opcode/await_stm/mod.rs

@ -1,6 +1,9 @@
use boa_gc::{Gc, GcCell};
use crate::{
builtins::{JsArgs, Promise},
object::FunctionBuilder,
native_function::NativeFunction,
object::FunctionObjectBuilder,
vm::{call_frame::GeneratorResumeKind, opcode::Operation, ShouldExit},
Context, JsResult, JsValue,
};
@ -28,37 +31,41 @@ impl Operation for Await {
// 3. Let fulfilledClosure be a new Abstract Closure with parameters (value) that captures asyncContext and performs the following steps when called:
// 4. Let onFulfilled be CreateBuiltinFunction(fulfilledClosure, 1, "", « »).
let on_fulfilled = FunctionBuilder::closure_with_captures(
let on_fulfilled = FunctionObjectBuilder::new(
context,
|_this, args, (environment, stack, frame), context| {
// a. Let prevContext be the running execution context.
// b. Suspend prevContext.
// c. Push asyncContext onto the execution context stack; asyncContext is now the running execution context.
// d. Resume the suspended evaluation of asyncContext using NormalCompletion(value) as the result of the operation that suspended it.
// e. Assert: When we reach this step, asyncContext has already been removed from the execution context stack and prevContext is the currently running execution context.
// f. Return undefined.
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
context.vm.push_frame(frame.clone());
context.vm.frame_mut().generator_resume_kind = GeneratorResumeKind::Normal;
context.vm.push(args.get_or_undefined(0).clone());
context.run()?;
*frame = context
.vm
.pop_frame()
.expect("generator call frame must exist");
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
Ok(JsValue::undefined())
},
(
context.realm.environments.clone(),
context.vm.stack.clone(),
context.vm.frame().clone(),
NativeFunction::from_copy_closure_with_captures(
|_this, args, captures, context| {
let mut captures = captures.borrow_mut();
let (environment, stack, frame) = &mut *captures;
// a. Let prevContext be the running execution context.
// b. Suspend prevContext.
// c. Push asyncContext onto the execution context stack; asyncContext is now the running execution context.
// d. Resume the suspended evaluation of asyncContext using NormalCompletion(value) as the result of the operation that suspended it.
// e. Assert: When we reach this step, asyncContext has already been removed from the execution context stack and prevContext is the currently running execution context.
// f. Return undefined.
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
context.vm.push_frame(frame.clone());
context.vm.frame_mut().generator_resume_kind = GeneratorResumeKind::Normal;
context.vm.push(args.get_or_undefined(0).clone());
context.run()?;
*frame = context
.vm
.pop_frame()
.expect("generator call frame must exist");
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
Ok(JsValue::undefined())
},
Gc::new(GcCell::new((
context.realm.environments.clone(),
context.vm.stack.clone(),
context.vm.frame().clone(),
))),
),
)
.name("")
@ -67,37 +74,41 @@ impl Operation for Await {
// 5. Let rejectedClosure be a new Abstract Closure with parameters (reason) that captures asyncContext and performs the following steps when called:
// 6. Let onRejected be CreateBuiltinFunction(rejectedClosure, 1, "", « »).
let on_rejected = FunctionBuilder::closure_with_captures(
let on_rejected = FunctionObjectBuilder::new(
context,
|_this, args, (environment, stack, frame), context| {
// a. Let prevContext be the running execution context.
// b. Suspend prevContext.
// c. Push asyncContext onto the execution context stack; asyncContext is now the running execution context.
// d. Resume the suspended evaluation of asyncContext using ThrowCompletion(reason) as the result of the operation that suspended it.
// e. Assert: When we reach this step, asyncContext has already been removed from the execution context stack and prevContext is the currently running execution context.
// f. Return undefined.
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
context.vm.push_frame(frame.clone());
context.vm.frame_mut().generator_resume_kind = GeneratorResumeKind::Throw;
context.vm.push(args.get_or_undefined(0).clone());
context.run()?;
*frame = context
.vm
.pop_frame()
.expect("generator call frame must exist");
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
Ok(JsValue::undefined())
},
(
context.realm.environments.clone(),
context.vm.stack.clone(),
context.vm.frame().clone(),
NativeFunction::from_copy_closure_with_captures(
|_this, args, captures, context| {
let mut captures = captures.borrow_mut();
let (environment, stack, frame) = &mut *captures;
// a. Let prevContext be the running execution context.
// b. Suspend prevContext.
// c. Push asyncContext onto the execution context stack; asyncContext is now the running execution context.
// d. Resume the suspended evaluation of asyncContext using ThrowCompletion(reason) as the result of the operation that suspended it.
// e. Assert: When we reach this step, asyncContext has already been removed from the execution context stack and prevContext is the currently running execution context.
// f. Return undefined.
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
context.vm.push_frame(frame.clone());
context.vm.frame_mut().generator_resume_kind = GeneratorResumeKind::Throw;
context.vm.push(args.get_or_undefined(0).clone());
context.run()?;
*frame = context
.vm
.pop_frame()
.expect("generator call frame must exist");
std::mem::swap(&mut context.realm.environments, environment);
std::mem::swap(&mut context.vm.stack, stack);
Ok(JsValue::undefined())
},
Gc::new(GcCell::new((
context.realm.environments.clone(),
context.vm.stack.clone(),
context.vm.frame().clone(),
))),
),
)
.name("")

157
boa_examples/src/bin/closures.rs

@ -1,33 +1,40 @@
// This example goes into the details on how to pass closures as functions
// inside Rust and call them from Javascript.
// This example goes into the details on how to pass closures as functions inside Rust and call them
// from Javascript.
use std::cell::{Cell, RefCell};
use boa_engine::{
js_string,
object::{FunctionBuilder, JsObject},
native_function::NativeFunction,
object::{builtins::JsArray, FunctionObjectBuilder, JsObject},
property::{Attribute, PropertyDescriptor},
string::utf16,
Context, JsError, JsString, JsValue,
Context, JsError, JsNativeError, JsString, JsValue,
};
use boa_gc::{Finalize, Trace};
use boa_gc::{Finalize, GcCell, Trace};
fn main() -> Result<(), JsError> {
// We create a new `Context` to create a new Javascript executor.
let mut context = Context::default();
// We make some operations in Rust that return a `Copy` value that we want
// to pass to a Javascript function.
// We make some operations in Rust that return a `Copy` value that we want to pass to a Javascript
// function.
let variable = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1;
// We register a global closure function that has the name 'closure' with length 0.
context.register_global_closure("closure", 0, move |_, _, _| {
println!("Called `closure`");
// `variable` is captured from the main function.
println!("variable = {variable}");
println!();
context.register_global_callable(
"closure",
0,
NativeFunction::from_copy_closure(move |_, _, _| {
println!("Called `closure`");
// `variable` is captured from the main function.
println!("variable = {variable}");
println!();
// We return the moved variable as a `JsValue`.
Ok(JsValue::new(variable))
})?;
// We return the moved variable as a `JsValue`.
Ok(JsValue::new(variable))
}),
);
assert_eq!(context.eval("closure()")?, 255.into());
@ -59,34 +66,38 @@ fn main() -> Result<(), JsError> {
object,
};
// We can use `FunctionBuilder` to define a closure with additional
// captures.
let js_function = FunctionBuilder::closure_with_captures(
// We can use `FunctionBuilder` to define a closure with additional captures and custom property
// attributes.
let js_function = FunctionObjectBuilder::new(
&mut context,
|_, _, captures, context| {
println!("Called `createMessage`");
// We obtain the `name` property of `captures.object`
let name = captures.object.get("name", context)?;
// We create a new message from our captured variable.
let message = js_string!(
utf16!("message from `"),
&name.to_string(context)?,
utf16!("`: "),
&captures.greeting
);
// We can also mutate the moved data inside the closure.
captures.greeting = js_string!(&captures.greeting, utf16!(" Hello!"));
println!("{}", message.to_std_string_escaped());
println!();
// We convert `message` into `JsValue` to be able to return it.
Ok(message.into())
},
// Here is where we move `clone_variable` into the closure.
clone_variable,
NativeFunction::from_copy_closure_with_captures(
|_, _, captures, context| {
let mut captures = captures.borrow_mut();
let BigStruct { greeting, object } = &mut *captures;
println!("Called `createMessage`");
// We obtain the `name` property of `captures.object`
let name = object.get("name", context)?;
// We create a new message from our captured variable.
let message = js_string!(
utf16!("message from `"),
&name.to_string(context)?,
utf16!("`: "),
greeting
);
// We can also mutate the moved data inside the closure.
captures.greeting = js_string!(greeting, utf16!(" Hello!"));
println!("{}", message.to_std_string_escaped());
println!();
// We convert `message` into `JsValue` to be able to return it.
Ok(message.into())
},
// Here is where we move `clone_variable` into the closure.
GcCell::new(clone_variable),
),
)
// And here we assign `createMessage` to the `name` property of the closure.
.name("createMessage")
@ -102,7 +113,7 @@ fn main() -> Result<(), JsError> {
// We pass `js_function` as a property value.
js_function,
// We assign to the "createMessage" property the desired attributes.
Attribute::WRITABLE | Attribute::NON_ENUMERABLE | Attribute::CONFIGURABLE,
Attribute::READONLY | Attribute::NON_ENUMERABLE | Attribute::PERMANENT,
);
assert_eq!(
@ -119,5 +130,65 @@ fn main() -> Result<(), JsError> {
// We have moved `Clone` variables into a closure and executed that closure
// inside Javascript!
// ADVANCED
// If we can ensure the captured variables are not traceable by the garbage collector,
// we can pass any static closure easily.
let index = Cell::new(0i32);
let numbers = RefCell::new(Vec::new());
// We register a global closure that is not `Copy`.
context.register_global_callable(
"enumerate",
0,
// Note that it is required to use `unsafe` code, since the compiler cannot verify that the
// types captured by the closure are not traceable.
unsafe {
NativeFunction::from_closure(move |_, _, context| {
println!("Called `enumerate`");
// `index` is captured from the main function.
println!("index = {}", index.get());
println!();
numbers.borrow_mut().push(index.get());
index.set(index.get() + 1);
// We return the moved variable as a `JsValue`.
Ok(
JsArray::from_iter(
numbers.borrow().iter().cloned().map(JsValue::from),
context,
)
.into(),
)
})
},
);
// First call should return the array `[0]`.
let result = context.eval("enumerate()")?;
let object = result
.as_object()
.cloned()
.ok_or_else(|| JsNativeError::typ().with_message("not an array!"))?;
let array = JsArray::from_object(object)?;
assert_eq!(array.get(0, &mut context)?, JsValue::from(0i32));
assert_eq!(array.get(1, &mut context)?, JsValue::undefined());
// First call should return the array `[0, 1]`.
let result = context.eval("enumerate()")?;
let object = result
.as_object()
.cloned()
.ok_or_else(|| JsNativeError::typ().with_message("not an array!"))?;
let array = JsArray::from_object(object)?;
assert_eq!(array.get(0, &mut context)?, JsValue::from(0i32));
assert_eq!(array.get(1, &mut context)?, JsValue::from(1i32));
assert_eq!(array.get(2, &mut context)?, JsValue::undefined());
// We have moved non-traceable variables into a closure and executed that closure inside Javascript!
Ok(())
}

40
boa_examples/src/bin/jsarray.rs

@ -1,7 +1,8 @@
// This example shows how to manipulate a Javascript array using Rust code.
use boa_engine::{
object::{builtins::JsArray, FunctionBuilder},
native_function::NativeFunction,
object::{builtins::JsArray, FunctionObjectBuilder},
string::utf16,
Context, JsResult, JsValue,
};
@ -60,17 +61,23 @@ fn main() -> JsResult<()> {
let joined_array = array.join(Some("::".into()), context)?;
assert_eq!(&joined_array, utf16!("14::false::false::false::10"));
let filter_callback = FunctionBuilder::native(context, |_this, args, _context| {
Ok(args.get(0).cloned().unwrap_or_default().is_number().into())
})
let filter_callback = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(|_this, args, _context| {
Ok(args.get(0).cloned().unwrap_or_default().is_number().into())
}),
)
.build();
let map_callback = FunctionBuilder::native(context, |_this, args, context| {
args.get(0)
.cloned()
.unwrap_or_default()
.pow(&JsValue::new(2), context)
})
let map_callback = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(|_this, args, context| {
args.get(0)
.cloned()
.unwrap_or_default()
.pow(&JsValue::new(2), context)
}),
)
.build();
let mut data = Vec::new();
@ -88,12 +95,15 @@ fn main() -> JsResult<()> {
assert_eq!(&chained_array.join(None, context)?, utf16!("196,1,2,3"));
let reduce_callback = FunctionBuilder::native(context, |_this, args, context| {
let accumulator = args.get(0).cloned().unwrap_or_default();
let value = args.get(1).cloned().unwrap_or_default();
let reduce_callback = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(|_this, args, context| {
let accumulator = args.get(0).cloned().unwrap_or_default();
let value = args.get(1).cloned().unwrap_or_default();
accumulator.add(&value, context)
})
accumulator.add(&value, context)
}),
)
.build();
assert_eq!(

16
boa_examples/src/bin/jstypedarray.rs

@ -1,7 +1,8 @@
// This example shows how to manipulate a Javascript array using Rust code.
use boa_engine::{
object::{builtins::JsUint8Array, FunctionBuilder},
native_function::NativeFunction,
object::{builtins::JsUint8Array, FunctionObjectBuilder},
property::Attribute,
Context, JsResult, JsValue,
};
@ -23,12 +24,15 @@ fn main() -> JsResult<()> {
sum += i;
}
let callback = FunctionBuilder::native(context, |_this, args, context| {
let accumulator = args.get(0).cloned().unwrap_or_default();
let value = args.get(1).cloned().unwrap_or_default();
let callback = FunctionObjectBuilder::new(
context,
NativeFunction::from_fn_ptr(|_this, args, context| {
let accumulator = args.get(0).cloned().unwrap_or_default();
let value = args.get(1).cloned().unwrap_or_default();
accumulator.add(&value, context)
})
accumulator.add(&value, context)
}),
)
.build();
assert_eq!(

7
boa_examples/src/bin/modulehandler.rs

@ -1,7 +1,10 @@
// This example implements a custom module handler which mimics
// the require/module.exports pattern
use boa_engine::{prelude::JsObject, property::Attribute, Context, JsResult, JsValue};
use boa_engine::{
native_function::NativeFunction, prelude::JsObject, property::Attribute, Context, JsResult,
JsValue,
};
use std::fs::read_to_string;
fn main() {
@ -17,7 +20,7 @@ fn main() {
let mut ctx = Context::default();
// Adding custom implementation that mimics 'require'
ctx.register_global_function("require", 0, require);
ctx.register_global_callable("require", 0, NativeFunction::from_fn_ptr(require));
// Adding custom object that mimics 'module.exports'
let moduleobj = JsObject::default();

2
boa_gc/src/internals/gc_box.rs

@ -102,7 +102,7 @@ impl fmt::Debug for GcBoxHeader {
/// A garbage collected allocation.
#[derive(Debug)]
pub(crate) struct GcBox<T: Trace + ?Sized + 'static> {
pub struct GcBox<T: Trace + ?Sized + 'static> {
pub(crate) header: GcBoxHeader,
pub(crate) value: T,
}

3
boa_gc/src/internals/mod.rs

@ -1,4 +1,5 @@
mod ephemeron_box;
mod gc_box;
pub(crate) use self::{ephemeron_box::EphemeronBox, gc_box::GcBox};
pub(crate) use self::ephemeron_box::EphemeronBox;
pub use self::gc_box::GcBox;

2
boa_gc/src/lib.rs

@ -95,7 +95,6 @@ mod trace;
pub(crate) mod internals;
use boa_profiler::Profiler;
use internals::GcBox;
use std::{
cell::{Cell, RefCell},
mem,
@ -105,6 +104,7 @@ use std::{
pub use crate::trace::{Finalize, Trace};
pub use boa_macros::{Finalize, Trace};
pub use cell::{GcCell, GcCellRef, GcCellRefMut};
pub use internals::GcBox;
pub use pointers::{Ephemeron, Gc, WeakGc};
type GcPointer = NonNull<GcBox<dyn Trace>>;

36
boa_gc/src/pointers/gc.rs

@ -47,6 +47,16 @@ impl<T: Trace> Gc<T> {
gc.set_root();
gc
}
/// Consumes the `Gc`, returning a wrapped raw pointer.
///
/// To avoid a memory leak, the pointer must be converted back to a `Gc` using [`Gc::from_raw`].
#[allow(clippy::use_self)]
pub fn into_raw(this: Gc<T>) -> NonNull<GcBox<T>> {
let ptr = this.inner_ptr.get();
std::mem::forget(this);
ptr
}
}
impl<T: Trace + ?Sized> Gc<T> {
@ -55,9 +65,26 @@ impl<T: Trace + ?Sized> Gc<T> {
GcBox::ptr_eq(this.inner(), other.inner())
}
/// Will return a new rooted `Gc` from a `GcBox` pointer
pub(crate) fn from_ptr(ptr: NonNull<GcBox<T>>) -> Self {
// SAFETY: the value provided as a pointer MUST be a valid GcBox.
/// Constructs a `Gc<T>` from a raw pointer.
///
/// The raw pointer must have been returned by a previous call to [`Gc<U>::into_raw`][Gc::into_raw]
/// where `U` must have the same size and alignment as `T`.
///
/// # Safety
///
/// This function is unsafe because improper use may lead to memory corruption, double-free,
/// or misbehaviour of the garbage collector.
#[must_use]
pub const unsafe fn from_raw(ptr: NonNull<GcBox<T>>) -> Self {
Self {
inner_ptr: Cell::new(ptr),
marker: PhantomData,
}
}
/// Return a rooted `Gc` from a `GcBox` pointer
pub(crate) unsafe fn from_ptr(ptr: NonNull<GcBox<T>>) -> Self {
// SAFETY: the caller must ensure that the pointer is valid.
unsafe {
ptr.as_ref().root_inner();
let gc = Self {
@ -159,7 +186,8 @@ unsafe impl<T: Trace + ?Sized> Trace for Gc<T> {
impl<T: Trace + ?Sized> Clone for Gc<T> {
fn clone(&self) -> Self {
Self::from_ptr(self.inner_ptr())
// SAFETY: `&self` is a valid Gc pointer.
unsafe { Self::from_ptr(self.inner_ptr()) }
}
}

19
boa_gc/src/trace.rs

@ -1,5 +1,6 @@
use std::{
borrow::{Cow, ToOwned},
cell::Cell,
collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque},
hash::{BuildHasher, Hash},
marker::PhantomData,
@ -445,3 +446,21 @@ where
}
});
}
impl<T: Trace> Finalize for Cell<Option<T>> {
fn finalize(&self) {
if let Some(t) = self.take() {
t.finalize();
self.set(Some(t));
}
}
}
unsafe impl<T: Trace> Trace for Cell<Option<T>> {
custom_trace!(this, {
if let Some(t) = this.take() {
mark(&t);
this.set(Some(t));
}
});
}

55
boa_tester/src/exec/mod.rs

@ -7,14 +7,13 @@ use super::{
};
use crate::read::ErrorType;
use boa_engine::{
builtins::JsArgs, object::FunctionBuilder, property::Attribute, Context, JsNativeErrorKind,
JsResult, JsValue,
builtins::JsArgs, native_function::NativeFunction, object::FunctionObjectBuilder,
property::Attribute, Context, JsNativeErrorKind, JsValue,
};
use boa_gc::{Finalize, Gc, GcCell, Trace};
use boa_parser::Parser;
use colored::Colorize;
use rayon::prelude::*;
use std::borrow::Cow;
use std::{borrow::Cow, cell::RefCell, rc::Rc};
impl TestSuite {
/// Runs the test suite.
@ -360,11 +359,25 @@ impl Test {
/// Registers the print function in the context.
fn register_print_fn(context: &mut Context<'_>, async_result: AsyncResult) {
// We use `FunctionBuilder` to define a closure with additional captures.
let js_function =
FunctionBuilder::closure_with_captures(context, test262_print, async_result)
.name("print")
.length(1)
.build();
let js_function = FunctionObjectBuilder::new(
context,
// SAFETY: `AsyncResult` has only non-traceable captures, making this safe.
unsafe {
NativeFunction::from_closure(move |_, args, context| {
let message = args
.get_or_undefined(0)
.to_string(context)?
.to_std_string_escaped();
if message != "Test262:AsyncTestComplete" {
*async_result.inner.borrow_mut() = Err(message);
}
Ok(JsValue::undefined())
})
},
)
.name("print")
.length(1)
.build();
context.register_global_property(
"print",
@ -375,33 +388,15 @@ impl Test {
}
/// Object which includes the result of the async operation.
#[derive(Debug, Clone, Trace, Finalize)]
#[derive(Debug, Clone)]
struct AsyncResult {
inner: Gc<GcCell<Result<(), String>>>,
inner: Rc<RefCell<Result<(), String>>>,
}
impl Default for AsyncResult {
fn default() -> Self {
Self {
inner: Gc::new(GcCell::new(Ok(()))),
inner: Rc::new(RefCell::new(Ok(()))),
}
}
}
/// `print()` function required by the test262 suite.
#[allow(clippy::unnecessary_wraps)]
fn test262_print(
_this: &JsValue,
args: &[JsValue],
async_result: &mut AsyncResult,
context: &mut Context<'_>,
) -> JsResult<JsValue> {
let message = args
.get_or_undefined(0)
.to_string(context)?
.to_std_string_escaped();
if message != "Test262:AsyncTestComplete" {
*async_result.inner.borrow_mut() = Err(message);
}
Ok(JsValue::undefined())
}

Loading…
Cancel
Save