Fold init and realm into a single option type, no need for NAME to be passed through

Author: jasonwilliams

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

@@ -834,7 +834,7 @@ impl BuiltInFunctionObject {
         };
 
         let object_borrow = object.borrow();
-        if object_borrow.is::<NativeFunctionObject>() {
+        if object_borrow.is::<NativeFunctionObject>() || object_borrow.is::<LazyBuiltIn>() {
             let name = {
                 // Is there a case here where if there is no name field on a value
                 // name should default to None? Do all functions have names set?
@@ -850,13 +850,6 @@ 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/context/intrinsics.rs

@@ -2,12 +2,11 @@
 
 use boa_gc::{Finalize, Trace, WeakGc};
 use boa_macros::js_str;
-use boa_string::JsString;
 
 use crate::{
     builtins::{
-        iterable::IteratorPrototypes, uri::UriFunctions, Array, BuiltInObject, Date,
-        IntrinsicObject, OrdinaryObject,
+        iterable::IteratorPrototypes, uri::UriFunctions, Array, Date, IntrinsicObject,
+        OrdinaryObject,
     },
     js_string,
     object::{
@@ -101,9 +100,9 @@ impl StandardConstructor {
     }
 
     /// Similar to `with_prototype`, but the prototype is lazily initialized.
-    fn lazy(init: fn(&Realm) -> (), name: JsString, realm_inner: WeakGc<RealmInner>) -> Self {
+    fn lazy(init: fn(&Realm) -> (), realm_inner: WeakGc<RealmInner>) -> Self {
         Self {
-            constructor: JsFunction::lazy_intrinsic_function(true, init, name, realm_inner),
+            constructor: JsFunction::lazy_intrinsic_function(true, init, realm_inner),
             prototype: JsObject::default(),
         }
     }
@@ -225,14 +224,14 @@ impl StandardConstructors {
             )),
             async_generator_function: StandardConstructor::default(),
             proxy: StandardConstructor::default(),
-            date: StandardConstructor::lazy(Date::init, Date::NAME, realm_inner.clone()),
+            date: StandardConstructor::lazy(Date::init, 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::lazy(Array::init, Array::NAME, realm_inner.clone()),
+            array: StandardConstructor::lazy(Array::init, 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

@@ -5,8 +5,6 @@ use crate::{
     value::TryFromJs, Context, JsNativeError, JsResult, JsValue, NativeFunction, TryIntoJsResult,
 };
 use boa_gc::{Finalize, Trace, WeakGc};
-use boa_string::JsString;
-use std::cell::Cell;
 use std::marker::PhantomData;
 use std::ops::Deref;
 
@@ -109,7 +107,6 @@ impl JsFunction {
     pub(crate) fn lazy_intrinsic_function(
         constructor: bool,
         init: fn(&Realm),
-        name: JsString,
         realm_inner: WeakGc<RealmInner>,
     ) -> Self {
         let kind = if constructor {
@@ -122,11 +119,8 @@ impl JsFunction {
             inner: JsObject::from_proto_and_data(
                 None,
                 LazyBuiltIn {
-                    init,
-                    is_initialized: Cell::new(false),
+                    init_and_realm: Some((init, realm_inner)),
                     kind,
-                    name,
-                    realm_inner: Some(realm_inner),
                 },
             ),
         }