i needed to see the borrowed state of objects in the debug output, keeping for now.

Exotic objects need a specific Lazy equivalent so we can identify them in brand checks

Author: jasonwilliams

core/engine/src/context/intrinsics.rs

@@ -5,8 +5,8 @@ use boa_macros::js_str;
 
 use crate::{
     builtins::{
-        function::ConstructorKind, iterable::IteratorPrototypes, uri::UriFunctions, Array, Date,
-        IntrinsicObject, Json, Math, OrdinaryObject, RegExp, String,
+        function::ConstructorKind, iterable::IteratorPrototypes, uri::UriFunctions, Array,
+        IntrinsicObject, OrdinaryObject,
     },
     js_string,
     native_function::NativeFunctionObject,
@@ -51,7 +51,7 @@ impl Intrinsics {
 
         Some(Self {
             constructors,
-            objects: IntrinsicObjects::uninit(realm_inner)?,
+            objects: IntrinsicObjects::uninit()?,
             templates,
         })
     }
@@ -120,7 +120,7 @@ impl StandardConstructor {
     /// array[0] = 42; // Sets the first element to 42
     /// console.log(array[0]); // Logs 42
     /// ```
-    fn lazy(init: fn(&Realm) -> (), realm_inner: &WeakGc<RealmInner>) -> Self {
+    fn lazy_array(init: fn(&Realm) -> (), realm_inner: &WeakGc<RealmInner>) -> Self {
         let obj: JsObject<LazyBuiltIn> = JsObject::new_unique(
             None,
             LazyBuiltIn {
@@ -136,7 +136,7 @@ impl StandardConstructor {
 
         Self {
             constructor: constructor.clone(),
-            prototype: JsObject::lazy_prototype(obj),
+            prototype: JsObject::lazy_array_prototype(obj),
         }
     }
 
@@ -264,7 +264,7 @@ impl StandardConstructors {
             },
             async_function: StandardConstructor::default(),
             generator_function: StandardConstructor::default(),
-            array: StandardConstructor::lazy(Array::init, realm_inner),
+            array: StandardConstructor::lazy_array(Array::init, realm_inner),
             bigint: StandardConstructor::default(),
             number: StandardConstructor::with_prototype(JsObject::from_proto_and_data(None, 0.0)),
             boolean: StandardConstructor::with_prototype(JsObject::from_proto_and_data(
@@ -1165,7 +1165,7 @@ impl IntrinsicObjects {
     ///
     /// [`Realm::initialize`]: crate::realm::Realm::initialize
     #[allow(clippy::unnecessary_wraps)]
-    pub(crate) fn uninit(realm_inner: &WeakGc<RealmInner>) -> Option<Self> {
+    pub(crate) fn uninit() -> Option<Self> {
         Some(Self {
             reflect: JsObject::default(),
             math: JsObject::default(),

core/engine/src/object/builtins/lazy_array_prototype.rs

@@ -0,0 +1,226 @@
+use crate::{
+    object::{
+        internal_methods::{
+            non_existant_call, non_existant_construct, ordinary_define_own_property,
+            ordinary_delete, ordinary_get, ordinary_get_own_property, ordinary_get_prototype_of,
+            ordinary_has_property, ordinary_is_extensible, ordinary_own_property_keys,
+            ordinary_prevent_extensions, ordinary_set, ordinary_set_prototype_of, ordinary_try_get,
+            InternalMethodContext, InternalObjectMethods,
+        },
+        JsPrototype,
+    },
+    property::{PropertyDescriptor, PropertyKey},
+    Context, JsData, JsObject, JsResult, JsValue,
+};
+use boa_gc::{Finalize, Trace};
+
+use super::LazyBuiltIn;
+
+/// The `LazyArrayPrototype` struct is responsible for ensuring that the prototype
+/// of a constructor is lazily initialized. In JavaScript, constructors have a
+/// `prototype` property that points to an object which is used as the prototype
+/// for instances created by that constructor.
+///
+/// The `LazyArrayPrototype` struct is used within `JsObject` (e.g., `JsObject<LazyPrototype>`)
+/// to defer the creation of the prototype object until it is actually needed.
+/// This lazy initialization helps improve performance by avoiding the creation
+/// of the prototype object until it is necessary.
+///
+/// Each `LazyArrayPrototype` instance points to the constructor's `lazyBuiltin` (via its
+/// object) and triggers the initialization of the prototype if any methods on
+/// the prototype are called.
+
+#[derive(Clone, Trace, Finalize, Debug)]
+#[allow(clippy::type_complexity)]
+pub struct LazyArrayPrototype {
+    pub(crate) constructor: JsObject<LazyBuiltIn>,
+}
+
+// Implement the trait for JsData by overriding all internal_methods by calling init on the LazyBuiltIn associated with this prototype
+impl JsData for LazyArrayPrototype {
+    fn internal_methods(&self) -> &'static InternalObjectMethods {
+        &LAZY_INTERNAL_METHODS
+    }
+}
+
+pub(crate) static LAZY_INTERNAL_METHODS: InternalObjectMethods = InternalObjectMethods {
+    __get_prototype_of__: lazy_get_prototype_of,
+    __set_prototype_of__: lazy_set_prototype_of,
+    __is_extensible__: lazy_is_extensible,
+    __prevent_extensions__: lazy_prevent_extensions,
+    __get_own_property__: lazy_get_own_property,
+    __define_own_property__: lazy_define_own_property,
+    __has_property__: lazy_has_property,
+    __try_get__: lazy_try_get,
+    __get__: lazy_get,
+    __set__: lazy_set,
+    __delete__: lazy_delete,
+    __own_property_keys__: lazy_own_property_keys,
+    __call__: non_existant_call,
+    __construct__: non_existant_construct,
+};
+
+pub(crate) fn lazy_get_prototype_of(
+    obj: &JsObject,
+    context: &mut Context,
+) -> JsResult<JsPrototype> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_get_prototype_of(obj, context)
+}
+
+pub(crate) fn lazy_set_prototype_of(
+    obj: &JsObject,
+    prototype: JsPrototype,
+    context: &mut Context,
+) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_set_prototype_of(obj, prototype, context)
+}
+pub(crate) fn lazy_is_extensible(obj: &JsObject, context: &mut Context) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_is_extensible(obj, context)
+}
+
+pub(crate) fn lazy_prevent_extensions(obj: &JsObject, context: &mut Context) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_prevent_extensions(obj, context)
+}
+
+pub(crate) fn lazy_get_own_property(
+    obj: &JsObject,
+    key: &PropertyKey,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<Option<PropertyDescriptor>> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_get_own_property(obj, key, context)
+}
+
+pub(crate) fn lazy_define_own_property(
+    obj: &JsObject,
+    key: &PropertyKey,
+    desc: PropertyDescriptor,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+
+    ordinary_define_own_property(obj, key, desc, context)
+}
+
+pub(crate) fn lazy_has_property(
+    obj: &JsObject,
+    key: &PropertyKey,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_has_property(obj, key, context)
+}
+
+pub(crate) fn lazy_try_get(
+    obj: &JsObject,
+    key: &PropertyKey,
+    receiver: JsValue,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<Option<JsValue>> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+
+    ordinary_try_get(obj, key, receiver, context)
+}
+
+pub(crate) fn lazy_get(
+    obj: &JsObject,
+    key: &PropertyKey,
+    receiver: JsValue,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<JsValue> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_get(obj, key, receiver, context)
+}
+
+pub(crate) fn lazy_set(
+    obj: &JsObject,
+    key: PropertyKey,
+    value: JsValue,
+    receiver: JsValue,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_set(obj, key, value, receiver, context)
+}
+
+pub(crate) fn lazy_delete(
+    obj: &JsObject,
+    key: &PropertyKey,
+    context: &mut InternalMethodContext<'_>,
+) -> JsResult<bool> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+    ordinary_delete(obj, key, context)
+}
+
+pub(crate) fn lazy_own_property_keys(
+    obj: &JsObject,
+    context: &mut Context,
+) -> JsResult<Vec<PropertyKey>> {
+    let lazy_prototype: JsObject<LazyArrayPrototype> = obj
+        .clone()
+        .downcast::<LazyArrayPrototype>()
+        .expect("obj is not a Builtin");
+    let lazy_built_in = &lazy_prototype.borrow_mut().data.constructor.clone();
+    LazyBuiltIn::ensure_init(lazy_built_in);
+
+    ordinary_own_property_keys(obj, context)
+}

core/engine/src/object/builtins/lazy_builtin.rs

@@ -23,6 +23,7 @@ use boa_gc::{Finalize, Trace, WeakGc};
 #[derive(Debug, Clone, Trace, Finalize)]
 pub(crate) enum BuiltinKind {
     Function(NativeFunctionObject),
+    #[allow(dead_code)]
     Ordinary,
 }
 

core/engine/src/object/builtins/mod.rs

@@ -17,6 +17,7 @@ mod jsset;
 mod jsset_iterator;
 mod jssharedarraybuffer;
 mod jstypedarray;
+mod lazy_array_prototype;
 mod lazy_builtin;
 mod lazy_prototype;
 
@@ -35,5 +36,6 @@ pub use jsset::*;
 pub use jsset_iterator::*;
 pub use jssharedarraybuffer::*;
 pub use jstypedarray::*;
+pub use lazy_array_prototype::*;
 pub use lazy_builtin::*;
 pub use lazy_prototype::*;

core/engine/src/object/jsobject.rs

@@ -5,8 +5,7 @@
 use super::{
     internal_methods::{InternalMethodContext, InternalObjectMethods, ORDINARY_INTERNAL_METHODS},
     shape::RootShape,
-    BuiltinKind, JsPrototype, LazyBuiltIn, LazyPrototype, NativeObject, Object, PrivateName,
-    PropertyMap,
+    JsPrototype, LazyArrayPrototype, LazyBuiltIn, NativeObject, Object, PrivateName, PropertyMap,
 };
 use crate::{
     builtins::{
@@ -18,11 +17,10 @@ use crate::{
     error::JsNativeError,
     js_string,
     property::{PropertyDescriptor, PropertyKey},
-    realm::{Realm, RealmInner},
     value::PreferredType,
     Context, JsResult, JsString, JsValue,
 };
-use boa_gc::{self, Finalize, Gc, GcBox, GcRefCell, Trace, WeakGc};
+use boa_gc::{self, Finalize, Gc, GcBox, GcRefCell, Trace};
 use boa_macros::js_str;
 use std::{
     cell::RefCell,
@@ -95,21 +93,10 @@ impl JsObject {
         }
     }
 
-    /// Creates a new lazy `JsObject` from its inner object and its vtable.
-    /// This object will call `init(realm)` when it's first accessed
-    pub(crate) fn lazy(init: fn(&Realm) -> (), realm_inner: &WeakGc<RealmInner>) -> Self {
-        let data = LazyBuiltIn {
-            init_and_realm: Some((init, realm_inner.clone())),
-            kind: BuiltinKind::Ordinary,
-        };
-
-        Self::from_proto_and_data(None, data)
-    }
-
-    /// Creates a new lazy `JsObject` from its inner object and its vtable.
+    /// Creates a new lazy array prototype object from its inner object and its vtable.
     /// This is used for built-in objects that are prototypes of Constructors.
-    pub(crate) fn lazy_prototype(constructor: JsObject<LazyBuiltIn>) -> Self {
-        Self::from_proto_and_data(None, LazyPrototype { constructor })
+    pub(crate) fn lazy_array_prototype(constructor: JsObject<LazyBuiltIn>) -> Self {
+        Self::from_proto_and_data(None, LazyArrayPrototype { constructor })
     }
 
     /// Creates a new ordinary object with its prototype set to the `Object` prototype.
@@ -300,6 +287,12 @@ impl JsObject {
     #[must_use]
     #[track_caller]
     pub fn is_array(&self) -> bool {
+        // The prototype of an array should be an exotic Array object.
+        // If its the lazyArrayPrototype we know its an array.
+        if self.is::<LazyArrayPrototype>() {
+            return true;
+        }
+
         std::ptr::eq(self.vtable(), &ARRAY_EXOTIC_INTERNAL_METHODS)
     }
 
@@ -948,6 +941,7 @@ impl<T: NativeObject + ?Sized> Debug for JsObject<T> {
         if !limiter.visited && !limiter.live {
             let ptr: *const _ = self.as_ref();
             let ptr = ptr.cast::<()>();
+            let borrow_flag = self.inner.object.flags.get();
             let obj = self.borrow();
             let kind = obj.data.type_name_of_value();
             if self.is_callable() {
@@ -963,10 +957,16 @@ impl<T: NativeObject + ?Sized> Debug for JsObject<T> {
                         .unwrap_or_default(),
                 };
 
-                return f.write_fmt(format_args!("({:?}) {:?} 0x{:X}", kind, name, ptr as usize));
+                return f.write_fmt(format_args!(
+                    "({:?}) {:?} 0x{:X} {:?}",
+                    kind, name, ptr as usize, borrow_flag
+                ));
             }
 
-            f.write_fmt(format_args!("({:?}) 0x{:X}", kind, ptr as usize))
+            f.write_fmt(format_args!(
+                "({:?}) 0x{:X} {:?}",
+                kind, ptr as usize, borrow_flag
+            ))
         } else {
             f.write_str("{ ... }")
         }