LibJS+LibWeb: Restore type safety of Realm::set_global_object()

The changes from 8a03b17 to allow any JS::Value aren't a good fit, as
shown by the excessive amount of verify_cast needed :^)

Userland/Libraries/LibJS/Contrib/Test262/$262Object.cpp

@@ -61,7 +61,7 @@ JS_DEFINE_NATIVE_FUNCTION($262Object::create_realm)
     VERIFY(realm);
     auto* realm_global_object = vm.heap().allocate_without_global_object<GlobalObject>(*realm);
     VERIFY(realm_global_object);
-    realm->set_global_object(realm_global_object, js_undefined());
+    realm->set_global_object(realm_global_object, nullptr);
     realm_global_object->set_associated_realm(*realm);
     realm_global_object->initialize_global_object();
     return Value(realm_global_object->$262());

Userland/Libraries/LibJS/Interpreter.h

@@ -47,13 +47,11 @@ public:
 
         interpreter->m_global_execution_context = MUST(Realm::initialize_host_defined_realm(
             vm,
-            [&](Realm& realm) -> Value {
+            [&](Realm& realm) -> GlobalObject* {
                 global_object = interpreter->heap().allocate_without_global_object<GlobalObjectType>(realm, forward<Args>(args)...);
                 return global_object;
             },
-            [](Realm&) -> Value {
-                return js_undefined();
-            }));
+            nullptr));
 
         // NOTE: These are not in the spec.
         static FlyString global_execution_context_name = "(global execution context)";

Userland/Libraries/LibJS/Runtime/Realm.cpp

@@ -21,7 +21,7 @@ Realm* Realm::create(VM& vm)
 }
 
 // 9.6 InitializeHostDefinedRealm ( ), https://tc39.es/ecma262/#sec-initializehostdefinedrealm
-ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> Realm::initialize_host_defined_realm(VM& vm, Function<Value(Realm&)> create_global_object, Function<Value(Realm&)> create_global_this_value)
+ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> Realm::initialize_host_defined_realm(VM& vm, Function<GlobalObject*(Realm&)> create_global_object, Function<GlobalObject*(Realm&)> create_global_this_value)
 {
     DeferGC defer_gc(vm.heap());
 
@@ -46,20 +46,16 @@ ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> Realm::initialize_host_define
     // 7. If the host requires use of an exotic object to serve as realm's global object,
     //    let global be such an object created in a host-defined manner.
     //    Otherwise, let global be undefined, indicating that an ordinary object should be created as the global object.
-    Value global;
+    GlobalObject* global = nullptr;
     if (create_global_object)
         global = create_global_object(*realm);
-    else
-        global = js_undefined();
 
     // 8. If the host requires that the this binding in realm's global scope return an object other than the global object,
     //    let thisValue be such an object created in a host-defined manner.
     //    Otherwise, let thisValue be undefined, indicating that realm's global this binding should be the global object.
-    Value this_value;
+    GlobalObject* this_value = nullptr;
     if (create_global_this_value)
         this_value = create_global_this_value(*realm);
-    else
-        this_value = js_undefined();
 
     // 9. Perform SetRealmGlobalObject(realm, global, thisValue).
     realm->set_global_object(global, this_value);
@@ -75,34 +71,33 @@ ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> Realm::initialize_host_define
 }
 
 // 9.3.3 SetRealmGlobalObject ( realmRec, globalObj, thisValue ), https://tc39.es/ecma262/#sec-setrealmglobalobject
-void Realm::set_global_object(Value global_object, Value this_value)
+void Realm::set_global_object(GlobalObject* global_object, GlobalObject* this_value)
 {
     // 1. If globalObj is undefined, then
-    if (global_object.is_undefined()) {
+    if (global_object == nullptr) {
         // NOTE: Step 1 is not supported, the global object must be allocated elsewhere.
         VERIFY_NOT_REACHED();
     }
 
     // 2. Assert: Type(globalObj) is Object.
-    VERIFY(global_object.is_object());
-    VERIFY(is<GlobalObject>(global_object.as_object()));
+    VERIFY(global_object);
 
     // Non-standard
-    verify_cast<GlobalObject>(global_object.as_object()).set_associated_realm(*this);
+    global_object->set_associated_realm(*this);
 
     // 3. If thisValue is undefined, set thisValue to globalObj.
-    if (this_value.is_undefined())
+    if (this_value == nullptr)
         this_value = global_object;
 
     // Non-standard
-    VERIFY(this_value.is_object());
+    VERIFY(this_value);
 
     // 4. Set realmRec.[[GlobalObject]] to globalObj.
-    m_global_object = &verify_cast<GlobalObject>(global_object.as_object());
+    m_global_object = global_object;
 
     // 5. Let newGlobalEnv be NewGlobalEnvironment(globalObj, thisValue).
     // 6. Set realmRec.[[GlobalEnv]] to newGlobalEnv.
-    m_global_environment = m_global_object->heap().allocate_without_global_object<GlobalEnvironment>(verify_cast<GlobalObject>(global_object.as_object()), this_value.as_object());
+    m_global_environment = m_global_object->heap().allocate_without_global_object<GlobalEnvironment>(*global_object, *this_value);
 
     // 7. Return unused.
 }

Userland/Libraries/LibJS/Runtime/Realm.h

@@ -26,9 +26,9 @@ public:
     Realm() = default;
 
     static Realm* create(VM&);
-    static ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> initialize_host_defined_realm(VM&, Function<Value(Realm&)> create_global_object, Function<Value(Realm&)> create_global_this_value);
+    static ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> initialize_host_defined_realm(VM&, Function<GlobalObject*(Realm&)> create_global_object, Function<GlobalObject*(Realm&)> create_global_this_value);
 
-    void set_global_object(Value global_object, Value this_value);
+    void set_global_object(GlobalObject* global_object, GlobalObject* this_value);
 
     [[nodiscard]] GlobalObject& global_object() const { return *m_global_object; }
     [[nodiscard]] GlobalEnvironment& global_environment() const { return *m_global_environment; }

Userland/Libraries/LibJS/Runtime/ShadowRealmConstructor.cpp

@@ -64,7 +64,7 @@ ThrowCompletionOr<Object*> ShadowRealmConstructor::construct(FunctionObject& new
 
     // 10. Perform ? SetRealmGlobalObject(realmRec, undefined, undefined).
     auto* new_global_object = vm.heap().allocate_without_global_object<GlobalObject>(*realm);
-    realm->set_global_object(new_global_object, js_undefined());
+    realm->set_global_object(new_global_object, nullptr);
     new_global_object->initialize_global_object();
 
     // TODO: I don't think we should have these exactly like this, that doesn't work well with how