good working state

Author: jasonwilliams

.vscode/tasks.json

@@ -37,7 +37,7 @@
       "type": "process",
       "label": "Run JS file",
       "command": "cargo",
-      "args": ["run", "--bin", "boa", "${file}"],
+      "args": ["run", "--bin", "boa", "${workspaceFolder}/debug/script.js"],
       "group": {
         "kind": "build",
         "isDefault": true

core/engine/src/context/intrinsics.rs

@@ -6,7 +6,7 @@ use boa_macros::js_str;
 use crate::{
     builtins::{
         function::ConstructorKind, iterable::IteratorPrototypes, uri::UriFunctions, Array, Date,
-        IntrinsicObject, Math, OrdinaryObject,
+        IntrinsicObject, OrdinaryObject,
     },
     js_string,
     native_function::NativeFunctionObject,
@@ -100,9 +100,28 @@ impl StandardConstructor {
         }
     }
 
-    /// Similar to `with_prototype`, but the prototype is lazily initialized.
+    /// Build a constructor that is lazily initialized.
+    /// Both the constructor and the prototype are lazily initialized.
+    ///
+    /// For example: Both the initiation of the `Array` and accessing its prototype will fire `init` once.
+    /// This means that the actual creation of the array and the retrieval of its
+    /// prototype are deferred until they are actually needed.
+    ///
+    /// ## Example
+    ///
+    /// ```javascript
+    /// // Lazy initiation of the Array
+    /// let array = new Array(10); // Creates an array with 10 empty slots
+    ///
+    /// // Lazy access to the prototype
+    /// let prototype = Object.getPrototypeOf(array);
+    ///
+    /// // Accessing an index in the array
+    /// 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 {
-        let obj = JsObject::from_proto_and_data(
+        let obj: JsObject<LazyBuiltIn> = JsObject::new_unique(
             None,
             LazyBuiltIn {
                 init_and_realm: Some((init, realm_inner.clone())),
@@ -113,11 +132,11 @@ impl StandardConstructor {
                 }),
             },
         );
-        let constructor = JsFunction::from_object_unchecked(obj);
+        let constructor = JsFunction::from_object_unchecked(obj.clone().upcast());
 
         Self {
             constructor: constructor.clone(),
-            prototype: JsObject::lazy_prototype(obj.clone()),
+            prototype: JsObject::lazy_prototype(obj),
         }
     }
 
@@ -245,7 +264,7 @@ impl StandardConstructors {
             },
             async_function: StandardConstructor::default(),
             generator_function: StandardConstructor::default(),
-            array: StandardConstructor::lazy(Array::init, &realm_inner),
+            array: StandardConstructor::lazy(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(

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

@@ -1,15 +1,12 @@
 //! A Rust API wrapper for Boa's `Function` Builtin ECMAScript Object
-use crate::realm::{Realm, RealmInner};
 use crate::{
     builtins::function::ConstructorKind, native_function::NativeFunctionObject, object::JsObject,
     value::TryFromJs, Context, JsNativeError, JsResult, JsValue, NativeFunction, TryIntoJsResult,
 };
-use boa_gc::{Finalize, Trace, WeakGc};
+use boa_gc::{Finalize, Trace};
 use std::marker::PhantomData;
 use std::ops::Deref;
 
-use super::lazy_builtin::{BuiltinKind, LazyBuiltIn};
-
 /// A trait for converting a tuple of Rust values into a vector of `JsValue`,
 /// to be used as arguments for a JavaScript function.
 pub trait TryIntoJsArguments {
@@ -138,28 +135,6 @@ impl JsFunction {
         }
     }
 
-    /// Creates a new, lazy intrinsic functionobject with only its function internal methods set.
-    /// When the function is accessed it will call init from the procided init function
-    pub(crate) fn lazy_intrinsic_function(
-        constructor: bool,
-        init: fn(&Realm),
-        realm_inner: WeakGc<RealmInner>,
-    ) -> Self {
-        Self {
-            inner: JsObject::from_proto_and_data(
-                None,
-                LazyBuiltIn {
-                    init_and_realm: Some((init, realm_inner)),
-                    kind: BuiltinKind::Function(NativeFunctionObject {
-                        f: NativeFunction::from_fn_ptr(|_, _, _| Ok(JsValue::undefined())),
-                        constructor: constructor.then_some(ConstructorKind::Base),
-                        realm: None,
-                    }),
-                },
-            ),
-        }
-    }
-
     /// Creates a [`JsFunction`] from a [`JsObject`], or returns `None` if the object is not a function.
     ///
     /// This does not clone the fields of the function, it only does a shallow clone of the object.

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

@@ -24,8 +24,7 @@ pub(crate) enum BuiltinKind {
     Ordinary,
 }
 
-/// A builtin function. Used for lazy initialization of builtins.
-
+/// A Lazy Built-in data structure. Used for lazy initialization of builtins.
 #[derive(Clone, Finalize, Debug)]
 #[allow(clippy::type_complexity)]
 pub struct LazyBuiltIn {
@@ -44,8 +43,9 @@ impl LazyBuiltIn {
         }
     }
 
-    pub(crate) fn ensure_init(mut built_in: Self) {
-        if let Some((init, realm_inner)) = built_in.init_and_realm.take() {
+    pub(crate) fn ensure_init(built_in: &JsObject<LazyBuiltIn>) {
+        let borrowed_built_in = built_in.borrow_mut().data.init_and_realm.take();
+        if let Some((init, realm_inner)) = borrowed_built_in {
             let realm = &Realm {
                 inner: realm_inner.upgrade().expect("realm_inner not set"),
             };
@@ -100,7 +100,7 @@ pub(crate) fn lazy_get_prototype_of(
     context: &mut Context,
 ) -> JsResult<JsPrototype> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_get_prototype_of(obj, context)
 }
 
@@ -110,18 +110,18 @@ pub(crate) fn lazy_set_prototype_of(
     context: &mut Context,
 ) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_set_prototype_of(obj, prototype, context)
 }
 pub(crate) fn lazy_is_extensible(obj: &JsObject, context: &mut Context) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_is_extensible(obj, context)
 }
 
 pub(crate) fn lazy_prevent_extensions(obj: &JsObject, context: &mut Context) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_prevent_extensions(obj, context)
 }
 
@@ -131,7 +131,7 @@ pub(crate) fn lazy_get_own_property(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<Option<PropertyDescriptor>> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_get_own_property(obj, key, context)
 }
 
@@ -142,7 +142,7 @@ pub(crate) fn lazy_define_own_property(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
 
     ordinary_define_own_property(obj, key, desc, context)
 }
@@ -153,7 +153,7 @@ pub(crate) fn lazy_has_property(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_has_property(obj, key, context)
 }
 
@@ -164,7 +164,7 @@ pub(crate) fn lazy_try_get(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<Option<JsValue>> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
 
     ordinary_try_get(obj, key, receiver, context)
 }
@@ -176,7 +176,7 @@ pub(crate) fn lazy_get(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<JsValue> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_get(obj, key, receiver, context)
 }
 
@@ -188,7 +188,7 @@ pub(crate) fn lazy_set(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_set(obj, key, value, receiver, context)
 }
 
@@ -198,7 +198,7 @@ pub(crate) fn lazy_delete(
     context: &mut InternalMethodContext<'_>,
 ) -> JsResult<bool> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
     ordinary_delete(obj, key, context)
 }
 
@@ -207,7 +207,7 @@ pub(crate) fn lazy_own_property_keys(
     context: &mut Context,
 ) -> JsResult<Vec<PropertyKey>> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
 
     ordinary_own_property_keys(obj, context)
 }
@@ -218,19 +218,20 @@ pub(crate) fn lazy_construct(
     context: &mut Context,
 ) -> JsResult<CallValue> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    let kind = &builtin.borrow().data.kind;
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
+    LazyBuiltIn::ensure_init(&builtin);
+    let kind = &builtin.borrow().data.kind.clone();
 
     match kind {
         BuiltinKind::Ordinary => Err(JsNativeError::typ()
             .with_message("not a constructor")
             .with_realm(context.realm().clone())
             .into()),
-        BuiltinKind::Function(constructor) => Ok((constructor.internal_methods().__construct__)(
-            obj,
-            argument_count,
-            context,
-        )?),
+        BuiltinKind::Function(constructor) => {
+            let construct = constructor.internal_methods().__construct__;
+            // builtin needs to be dropped before calling the constructor to avoid a double borrow
+            drop(builtin);
+            Ok(construct(obj, argument_count, context)?)
+        }
     }
 }
 
@@ -240,19 +241,18 @@ pub(crate) fn lazy_call(
     context: &mut Context,
 ) -> JsResult<CallValue> {
     let builtin: JsObject<LazyBuiltIn> = obj.clone().downcast().expect("obj is not a Builtin");
-    let kind = &builtin.borrow().data.kind;
-
-    LazyBuiltIn::ensure_init(builtin.borrow_mut().data.clone());
-
+    LazyBuiltIn::ensure_init(&builtin);
+    let kind = &builtin.borrow().data.kind.clone();
     match kind {
         BuiltinKind::Ordinary => Err(JsNativeError::typ()
             .with_message("not a constructor")
             .with_realm(context.realm().clone())
             .into()),
-        BuiltinKind::Function(function) => Ok((function.internal_methods().__call__)(
-            obj,
-            argument_count,
-            context,
-        )?),
+        BuiltinKind::Function(function) => {
+            let call = function.internal_methods().__call__;
+            // builtin needs to be dropped before calling the constructor to avoid a double borrow
+            drop(builtin);
+            Ok(call(obj, argument_count, context)?)
+        }
     }
 }