From b3730bb40ce7be78afee9871561f40c24c06f032 Mon Sep 17 00:00:00 2001 From: Haled Odat <8566042+HalidOdat@users.noreply.github.com> Date: Sat, 27 May 2023 21:08:38 +0200 Subject: [PATCH] Remove some more old builtin code --- boa_engine/src/builtins/mod.rs | 198 --------------------------------- 1 file changed, 198 deletions(-) diff --git a/boa_engine/src/builtins/mod.rs b/boa_engine/src/builtins/mod.rs index 884fded777..304796c0cd 100644 --- a/boa_engine/src/builtins/mod.rs +++ b/boa_engine/src/builtins/mod.rs @@ -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 { @@ -920,34 +919,10 @@ struct BuiltInConstructorWithPrototype<'ctx> { object_storage: Vec, object: JsObject, - prototype_property_table: PropertyTableInner, - prototype_storage: Vec, - prototype: JsObject, - __proto__: JsPrototype, - inherits: Option, - 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>(mut self, name: N) -> Self { - self.name = name.into(); - self - } - /// Adds a new static method to the builtin object. fn static_method( mut self, @@ -992,174 +967,6 @@ impl BuiltInConstructorWithPrototype<'_> { self } - /// Adds a new static accessor property to the builtin object. - fn static_accessor( - mut self, - key: K, - get: Option, - set: Option, - attribute: Attribute, - ) -> Self - where - K: Into, - { - 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(mut self, function: NativeFunctionPointer, binding: B, length: usize) -> Self - where - B: Into, - { - 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(mut self, key: K, value: V, attribute: Attribute) -> Self - where - K: Into, - V: Into, - { - 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( - mut self, - key: K, - get: Option, - set: Option, - attribute: Attribute, - ) -> Self - where - K: Into, - { - 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 { @@ -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, } } }