Skip to content

Commit

Permalink
Remove some more old builtin code
Browse files Browse the repository at this point in the history
  • Loading branch information
@HalidOdat
HalidOdat committed May 27, 2023
1 parent bbff508 commit 7907c49
Showing 1 changed file with 0 additions and 198 deletions.
198 changes: 0 additions & 198 deletions boa_engine/src/builtins/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -669,7 +669,6 @@ impl<'ctx> BuiltInBuilder {
}
}

#[allow(dead_code)]
impl BuiltInBuilderConstructorStaticShape<'_> {
/// Adds a new static method to the builtin object.
fn static_method(mut self, function: NativeFunctionPointer, length: usize) -> Self {
Expand Down Expand Up @@ -920,34 +919,10 @@ struct BuiltInConstructorWithPrototype<'ctx> {
object_storage: Vec<JsValue>,
object: JsObject,

prototype_property_table: PropertyTableInner,
prototype_storage: Vec<JsValue>,
prototype: JsObject,

__proto__: JsPrototype,
inherits: Option<JsObject>,
attributes: Attribute,
}

#[allow(dead_code)]
impl BuiltInConstructorWithPrototype<'_> {
/// Specify how many arguments the constructor function takes.
///
/// Default is `0`.
#[inline]
const fn length(mut self, length: usize) -> Self {
self.length = length;
self
}

/// Specify the name of the constructor function.
///
/// Default is `""`
fn name<N: Into<JsString>>(mut self, name: N) -> Self {
self.name = name.into();
self
}

/// Adds a new static method to the builtin object.
fn static_method<B>(
mut self,
Expand Down Expand Up @@ -992,174 +967,6 @@ impl BuiltInConstructorWithPrototype<'_> {
self
}

/// Adds a new static accessor property to the builtin object.
fn static_accessor<K>(
mut self,
key: K,
get: Option<JsFunction>,
set: Option<JsFunction>,
attribute: Attribute,
) -> Self
where
K: Into<PropertyKey>,
{
let mut attributes = SlotAttributes::from_bits_truncate(attribute.bits());
debug_assert!(!attributes.contains(SlotAttributes::WRITABLE));
attributes.set(SlotAttributes::GET, get.is_some());
attributes.set(SlotAttributes::SET, set.is_some());

let key = key.into();

debug_assert!(self.object_property_table.map.get(&key).is_none());
self.object_property_table.insert(key, attributes);
self.object_storage.extend([
get.map(JsValue::new).unwrap_or_default(),
set.map(JsValue::new).unwrap_or_default(),
]);
self
}

/// Specify the `[[Prototype]]` internal field of the builtin object.
///
/// Default is `Function.prototype` for constructors and `Object.prototype` for statics.
fn prototype(mut self, prototype: JsObject) -> Self {
self.__proto__ = Some(prototype);
self
}

/// Adds a new method to the constructor's prototype.
fn method<B>(mut self, function: NativeFunctionPointer, binding: B, length: usize) -> Self
where
B: Into<FunctionBinding>,
{
let binding = binding.into();
let function = BuiltInBuilder::callable(self.realm, function)
.name(binding.name)
.length(length)
.build();

debug_assert!(self
.prototype_property_table
.map
.get(&binding.binding)
.is_none());
self.prototype_property_table.insert(
binding.binding,
SlotAttributes::WRITABLE | SlotAttributes::CONFIGURABLE,
);
self.prototype_storage.push(function.into());
self
}

/// Adds a new data property to the constructor's prototype.
fn property<K, V>(mut self, key: K, value: V, attribute: Attribute) -> Self
where
K: Into<PropertyKey>,
V: Into<JsValue>,
{
let key = key.into();

debug_assert!(self.prototype_property_table.map.get(&key).is_none());
self.prototype_property_table
.insert(key, SlotAttributes::from_bits_truncate(attribute.bits()));
self.prototype_storage.push(value.into());
self
}

/// Adds new accessor property to the constructor's prototype.
fn accessor<K>(
mut self,
key: K,
get: Option<JsFunction>,
set: Option<JsFunction>,
attribute: Attribute,
) -> Self
where
K: Into<PropertyKey>,
{
let mut attributes = SlotAttributes::from_bits_truncate(attribute.bits());
debug_assert!(!attributes.contains(SlotAttributes::WRITABLE));
attributes.set(SlotAttributes::GET, get.is_some());
attributes.set(SlotAttributes::SET, set.is_some());

let key = key.into();

debug_assert!(self.prototype_property_table.map.get(&key).is_none());
self.prototype_property_table.insert(key, attributes);
self.prototype_storage.extend([
get.map(JsValue::new).unwrap_or_default(),
set.map(JsValue::new).unwrap_or_default(),
]);
self
}

/// Specifies the parent prototype which objects created by this constructor inherit from.
///
/// Default is `Object.prototype`.
#[allow(clippy::missing_const_for_fn)]
fn inherits(mut self, prototype: JsPrototype) -> Self {
self.inherits = prototype;
self
}

/// Specifies the property attributes of the prototype's "constructor" property.
const fn constructor_attributes(mut self, attributes: Attribute) -> Self {
self.attributes = attributes;
self
}

fn build(mut self) {
let function = function::Function::new(
function::FunctionKind::Native {
function: NativeFunction::from_fn_ptr(self.function),
constructor: (true).then_some(function::ConstructorKind::Base),
},
self.realm.clone(),
);

let length = self.length;
let name = self.name.clone();
let prototype = self.prototype.clone();
self = self.static_property("length", length, Attribute::CONFIGURABLE);
self = self.static_property("name", name, Attribute::CONFIGURABLE);
self = self.static_property(PROTOTYPE, prototype, Attribute::empty());

let attributes = self.attributes;
let object = self.object.clone();
self = self.property(CONSTRUCTOR, object, attributes);

{
let mut prototype = self.prototype.borrow_mut();
prototype
.properties_mut()
.shape
.as_unique()
.expect("The object should have a unique shape")
.override_internal(self.prototype_property_table, self.inherits);

let prototype_old_storage = std::mem::replace(
&mut prototype.properties_mut().storage,
self.prototype_storage,
);

debug_assert_eq!(prototype_old_storage.len(), 0);
}

let mut object = self.object.borrow_mut();
*object.kind_mut() = ObjectKind::Function(function);
object
.properties_mut()
.shape
.as_unique()
.expect("The object should have a unique shape")
.override_internal(self.object_property_table, self.__proto__);

let object_old_storage =
std::mem::replace(&mut object.properties_mut().storage, self.object_storage);

debug_assert_eq!(object_old_storage.len(), 0);
}

fn build_without_prototype(mut self) {
let function = function::Function::new(
function::FunctionKind::Native {
Expand Down Expand Up @@ -1269,12 +1076,7 @@ impl<'ctx> BuiltInBuilder {
object_property_table: PropertyTableInner::default(),
object_storage: Vec::default(),
object: constructor.constructor(),
prototype_property_table: PropertyTableInner::default(),
prototype_storage: Vec::default(),
prototype: constructor.prototype(),
__proto__: Some(realm.intrinsics().constructors().function().prototype()),
inherits: Some(realm.intrinsics().constructors().object().prototype()),
attributes: Attribute::WRITABLE | Attribute::CONFIGURABLE | Attribute::NON_ENUMERABLE,
}
}
}

0 comments on commit 7907c49

Please sign in to comment.