lazy builtins

core/engine/src/builtins/builder.rs

@@ -387,12 +387,6 @@ impl BuiltInConstructorWithPrototype<'_> {
         }
 
         let mut object = self.object.borrow_mut();
-        let function = object
-            .downcast_mut::<NativeFunctionObject>()
-            .expect("Builtin must be a function object");
-        function.f = NativeFunction::from_fn_ptr(self.function);
-        function.constructor = Some(ConstructorKind::Base);
-        function.realm = Some(self.realm.clone());
         object
             .properties_mut()
             .shape

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

@@ -29,7 +29,7 @@ use crate::{
             get_prototype_from_constructor, CallValue, InternalObjectMethods,
             ORDINARY_INTERNAL_METHODS,
         },
-        JsData, JsFunction, JsObject, PrivateElement, PrivateName,
+        JsData, JsFunction, JsObject, LazyBuiltIn, PrivateElement, PrivateName,
     },
     property::{Attribute, PropertyDescriptor, PropertyKey},
     realm::Realm,
@@ -850,6 +850,13 @@ impl BuiltInFunctionObject {
             );
         } else if object_borrow.is::<Proxy>() || object_borrow.is::<BoundFunction>() {
             return Ok(js_string!("function () { [native code] }").into());
+        } else if object_borrow.is::<LazyBuiltIn>() {
+            let name = object_borrow
+                .downcast_ref::<LazyBuiltIn>()
+                .map_or_else(|| js_string!(), |built_in| built_in.name.clone());
+            return Ok(
+                js_string!(js_str!("function "), &name, js_str!("() { [native code] }")).into(),
+            );
         }
 
         let function = object_borrow

core/engine/src/builtins/mod.rs

@@ -203,14 +203,13 @@ impl Realm {
         ForInIterator::init(self);
         Math::init(self);
         Json::init(self);
-        Array::init(self);
         ArrayIterator::init(self);
         Proxy::init(self);
         ArrayBuffer::init(self);
         SharedArrayBuffer::init(self);
         BigInt::init(self);
         Boolean::init(self);
-        Date::init(self);
+        // Date::init(self);
         DataView::init(self);
         Map::init(self);
         MapIterator::init(self);

core/engine/src/context/intrinsics.rs

@@ -1,17 +1,22 @@
 //! Data structures that contain intrinsic objects and constructors.
 
-use boa_gc::{Finalize, Trace};
+use boa_gc::{Finalize, Trace, WeakGc};
 use boa_macros::js_str;
+use boa_string::JsString;
 
 use crate::{
-    builtins::{iterable::IteratorPrototypes, uri::UriFunctions, Array, OrdinaryObject},
+    builtins::{
+        iterable::IteratorPrototypes, uri::UriFunctions, Array, BuiltInObject, Date,
+        IntrinsicObject, OrdinaryObject,
+    },
     js_string,
     object::{
         internal_methods::immutable_prototype::IMMUTABLE_PROTOTYPE_EXOTIC_INTERNAL_METHODS,
         shape::{shared_shape::template::ObjectTemplate, RootShape},
         JsFunction, JsObject, Object, CONSTRUCTOR, PROTOTYPE,
     },
     property::{Attribute, PropertyKey},
+    realm::{Realm, RealmInner},
     JsSymbol,
 };
 
@@ -40,8 +45,8 @@ impl Intrinsics {
     /// To initialize all the intrinsics with their spec properties, see [`Realm::initialize`].
     ///
     /// [`Realm::initialize`]: crate::realm::Realm::initialize
-    pub(crate) fn uninit(root_shape: &RootShape) -> Option<Self> {
-        let constructors = StandardConstructors::default();
+    pub(crate) fn uninit(root_shape: &RootShape, realm_inner: &WeakGc<RealmInner>) -> Option<Self> {
+        let constructors = StandardConstructors::new(realm_inner);
         let templates = ObjectTemplates::new(root_shape, &constructors);
 
         Some(Self {
@@ -95,6 +100,14 @@ impl StandardConstructor {
         }
     }
 
+    /// Similar to `with_prototype`, but the prototype is lazily initialized.
+    fn lazy(init: fn(&Realm) -> (), name: JsString, realm_inner: WeakGc<RealmInner>) -> Self {
+        Self {
+            constructor: JsFunction::lazy_intrinsic_function(true, init, name, realm_inner),
+            prototype: JsObject::default(),
+        }
+    }
+
     /// Build a constructor with a defined prototype.
     fn with_prototype(prototype: JsObject) -> Self {
         Self {
@@ -203,23 +216,23 @@ pub struct StandardConstructors {
     calendar: StandardConstructor,
 }
 
-impl Default for StandardConstructors {
-    fn default() -> Self {
+impl StandardConstructors {
+    fn new(realm_inner: &WeakGc<RealmInner>) -> Self {
         Self {
             object: StandardConstructor::with_prototype(JsObject::from_object_and_vtable(
                 Object::<OrdinaryObject>::default(),
                 &IMMUTABLE_PROTOTYPE_EXOTIC_INTERNAL_METHODS,
             )),
             async_generator_function: StandardConstructor::default(),
             proxy: StandardConstructor::default(),
-            date: StandardConstructor::default(),
+            date: StandardConstructor::lazy(Date::init, Date::NAME, realm_inner.clone()),
             function: StandardConstructor {
                 constructor: JsFunction::empty_intrinsic_function(true),
                 prototype: JsFunction::empty_intrinsic_function(false).into(),
             },
             async_function: StandardConstructor::default(),
             generator_function: StandardConstructor::default(),
-            array: StandardConstructor::with_prototype(JsObject::from_proto_and_data(None, Array)),
+            array: StandardConstructor::lazy(Array::init, Array::NAME, realm_inner.clone()),
             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,12 +1,17 @@
 //! 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};
+use boa_gc::{Finalize, Trace, WeakGc};
+use boa_string::JsString;
+use std::cell::Cell;
 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 {
@@ -99,6 +104,34 @@ 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),
+        name: JsString,
+        realm_inner: WeakGc<RealmInner>,
+    ) -> Self {
+        let kind = if constructor {
+            BuiltinKind::Function(Self::empty_intrinsic_function(constructor))
+        } else {
+            BuiltinKind::Ordinary
+        };
+
+        Self {
+            inner: JsObject::from_proto_and_data(
+                None,
+                LazyBuiltIn {
+                    init,
+                    is_initialized: Cell::new(false),
+                    kind,
+                    name,
+                    realm_inner: Some(realm_inner),
+                },
+            ),
+        }
+    }
+
     /// 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.