LibJS: Convert Heap::allocate{,_without_realm}() to NonnullGCPtr

2025-07-28 09:47:34 +00:00 · 2022-12-14 17:40:33 +00:00 · 2022-12-14 17:40:33 +00:00 · 22089436ed
commit 22089436ed
parent 2a66fc6cae
161 changed files with 367 additions and 370 deletions
--- a/Userland/Libraries/LibJS/Bytecode/Op.cpp
+++ b/Userland/Libraries/LibJS/Bytecode/Op.cpp
@ -816,7 +816,7 @@ void ContinuePendingUnwind::replace_references_impl(BasicBlock const& from, Basi

 ThrowCompletionOr<void> PushDeclarativeEnvironment::execute_impl(Bytecode::Interpreter& interpreter) const
 {
-    auto* environment = interpreter.vm().heap().allocate_without_realm<DeclarativeEnvironment>(interpreter.vm().lexical_environment());
+    auto environment = interpreter.vm().heap().allocate_without_realm<DeclarativeEnvironment>(interpreter.vm().lexical_environment());
    interpreter.vm().running_execution_context().lexical_environment = environment;
    interpreter.vm().running_execution_context().variable_environment = environment;
    return {};
--- a/Userland/Libraries/LibJS/Contrib/Test262/$262Object.cpp
+++ b/Userland/Libraries/LibJS/Contrib/Test262/$262Object.cpp
@ -59,7 +59,7 @@ JS_DEFINE_NATIVE_FUNCTION($262Object::clear_kept_objects)
 JS_DEFINE_NATIVE_FUNCTION($262Object::create_realm)
 {
    auto realm = Realm::create(vm);
-    auto* realm_global_object = vm.heap().allocate_without_realm<GlobalObject>(*realm);
+    auto realm_global_object = vm.heap().allocate_without_realm<GlobalObject>(*realm);
    VERIFY(realm_global_object);
    realm->set_global_object(realm_global_object, nullptr);
    set_default_global_bindings(*realm);
--- a/Userland/Libraries/LibJS/Heap/Heap.h
+++ b/Userland/Libraries/LibJS/Heap/Heap.h
@ -33,21 +33,21 @@ public:
    ~Heap();

    template<typename T, typename... Args>
-    T* allocate_without_realm(Args&&... args)
+    NonnullGCPtr<T> allocate_without_realm(Args&&... args)
    {
        auto* memory = allocate_cell(sizeof(T));
        new (memory) T(forward<Args>(args)...);
-        return static_cast<T*>(memory);
+        return *static_cast<T*>(memory);
    }

    template<typename T, typename... Args>
-    T* allocate(Realm& realm, Args&&... args)
+    NonnullGCPtr<T> allocate(Realm& realm, Args&&... args)
    {
        auto* memory = allocate_cell(sizeof(T));
        new (memory) T(forward<Args>(args)...);
        auto* cell = static_cast<T*>(memory);
        memory->initialize(realm);
-        return cell;
+        return *cell;
    }

    enum class CollectionType {
--- a/Userland/Libraries/LibJS/Module.cpp
+++ b/Userland/Libraries/LibJS/Module.cpp
@ -114,7 +114,7 @@ Object* Module::module_namespace_create(VM& vm, Vector<FlyString> unambiguous_na
    // 6. Let sortedExports be a List whose elements are the elements of exports ordered as if an Array of the same values had been sorted using %Array.prototype.sort% using undefined as comparefn.
    // 7. Set M.[[Exports]] to sortedExports.
    // 8. Create own properties of M corresponding to the definitions in 28.3.
-    Object* module_namespace = vm.heap().allocate<ModuleNamespaceObject>(realm, realm, this, move(unambiguous_names));
+    auto module_namespace = vm.heap().allocate<ModuleNamespaceObject>(realm, realm, this, move(unambiguous_names));

    // 9. Set module.[[Namespace]] to M.
    m_namespace = make_handle(module_namespace);
--- a/Userland/Libraries/LibJS/Runtime/AbstractOperations.cpp
+++ b/Userland/Libraries/LibJS/Runtime/AbstractOperations.cpp
@ -412,7 +412,7 @@ FunctionEnvironment* new_function_environment(ECMAScriptFunctionObject& function
    auto& heap = function.heap();

    // 1. Let env be a new function Environment Record containing no bindings.
-    auto* env = heap.allocate_without_realm<FunctionEnvironment>(function.environment());
+    auto env = heap.allocate_without_realm<FunctionEnvironment>(function.environment());

    // 2. Set env.[[FunctionObject]] to F.
    env->set_function_object(function);
@ -1101,7 +1101,7 @@ Object* create_mapped_arguments_object(VM& vm, FunctionObject& function, Vector<
    // 7. Set obj.[[Set]] as specified in 10.4.4.4.
    // 8. Set obj.[[Delete]] as specified in 10.4.4.5.
    // 9. Set obj.[[Prototype]] to %Object.prototype%.
-    auto* object = vm.heap().allocate<ArgumentsObject>(realm, realm, environment);
+    auto object = vm.heap().allocate<ArgumentsObject>(realm, realm, environment);

    // 14. Let index be 0.
    // 15. Repeat, while index < len,
--- a/Userland/Libraries/LibJS/Runtime/AbstractOperations.h
+++ b/Userland/Libraries/LibJS/Runtime/AbstractOperations.h
@ -135,7 +135,7 @@ ThrowCompletionOr<T*> ordinary_create_from_constructor(VM& vm, FunctionObject co
 {
    auto& realm = *vm.current_realm();
    auto* prototype = TRY(get_prototype_from_constructor(vm, constructor, intrinsic_default_prototype));
-    return realm.heap().allocate<T>(realm, forward<Args>(args)..., *prototype);
+    return realm.heap().allocate<T>(realm, forward<Args>(args)..., *prototype).ptr();
 }

 // 14.1 MergeLists ( a, b ), https://tc39.es/proposal-temporal/#sec-temporal-mergelists
--- a/Userland/Libraries/LibJS/Runtime/Accessor.h
+++ b/Userland/Libraries/LibJS/Runtime/Accessor.h
@ -19,7 +19,7 @@ class Accessor final : public Cell {
 public:
    static NonnullGCPtr<Accessor> create(VM& vm, FunctionObject* getter, FunctionObject* setter)
    {
-        return *vm.heap().allocate_without_realm<Accessor>(getter, setter);
+        return vm.heap().allocate_without_realm<Accessor>(getter, setter);
    }

    FunctionObject* getter() const { return m_getter; }
--- a/Userland/Libraries/LibJS/Runtime/AggregateError.cpp
+++ b/Userland/Libraries/LibJS/Runtime/AggregateError.cpp
@ -12,7 +12,7 @@ namespace JS {

 NonnullGCPtr<AggregateError> AggregateError::create(Realm& realm)
 {
-    return *realm.heap().allocate<AggregateError>(realm, *realm.intrinsics().aggregate_error_prototype());
+    return realm.heap().allocate<AggregateError>(realm, *realm.intrinsics().aggregate_error_prototype());
 }

 AggregateError::AggregateError(Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Array.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Array.cpp
@ -32,13 +32,13 @@ ThrowCompletionOr<NonnullGCPtr<Array>> Array::create(Realm& realm, u64 length, O
    // 3. Let A be MakeBasicObject(« [[Prototype]], [[Extensible]] »).
    // 4. Set A.[[Prototype]] to proto.
    // 5. Set A.[[DefineOwnProperty]] as specified in 10.4.2.1.
-    auto* array = realm.heap().allocate<Array>(realm, *prototype);
+    auto array = realm.heap().allocate<Array>(realm, *prototype);

    // 6. Perform ! OrdinaryDefineOwnProperty(A, "length", PropertyDescriptor { [[Value]]: 𝔽(length), [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }).
    MUST(array->internal_define_own_property(vm.names.length, { .value = Value(length), .writable = true, .enumerable = false, .configurable = false }));

    // 7. Return A.
-    return NonnullGCPtr { *array };
+    return array;
 }

 // 7.3.18 CreateArrayFromList ( elements ), https://tc39.es/ecma262/#sec-createarrayfromlist
--- a/Userland/Libraries/LibJS/Runtime/ArrayBuffer.cpp
+++ b/Userland/Libraries/LibJS/Runtime/ArrayBuffer.cpp
@ -17,17 +17,17 @@ ThrowCompletionOr<NonnullGCPtr<ArrayBuffer>> ArrayBuffer::create(Realm& realm, s
    if (buffer.is_error())
        return realm.vm().throw_completion<RangeError>(ErrorType::NotEnoughMemoryToAllocate, byte_length);

-    return NonnullGCPtr { *realm.heap().allocate<ArrayBuffer>(realm, buffer.release_value(), *realm.intrinsics().array_buffer_prototype()) };
+    return realm.heap().allocate<ArrayBuffer>(realm, buffer.release_value(), *realm.intrinsics().array_buffer_prototype());
 }

 NonnullGCPtr<ArrayBuffer> ArrayBuffer::create(Realm& realm, ByteBuffer buffer)
 {
-    return *realm.heap().allocate<ArrayBuffer>(realm, move(buffer), *realm.intrinsics().array_buffer_prototype());
+    return realm.heap().allocate<ArrayBuffer>(realm, move(buffer), *realm.intrinsics().array_buffer_prototype());
 }

 NonnullGCPtr<ArrayBuffer> ArrayBuffer::create(Realm& realm, ByteBuffer* buffer)
 {
-    return *realm.heap().allocate<ArrayBuffer>(realm, buffer, *realm.intrinsics().array_buffer_prototype());
+    return realm.heap().allocate<ArrayBuffer>(realm, buffer, *realm.intrinsics().array_buffer_prototype());
 }

 ArrayBuffer::ArrayBuffer(ByteBuffer buffer, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/ArrayIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/ArrayIterator.cpp
@ -11,7 +11,7 @@ namespace JS {

 NonnullGCPtr<ArrayIterator> ArrayIterator::create(Realm& realm, Value array, Object::PropertyKind iteration_kind)
 {
-    return *realm.heap().allocate<ArrayIterator>(realm, array, iteration_kind, *realm.intrinsics().array_iterator_prototype());
+    return realm.heap().allocate<ArrayIterator>(realm, array, iteration_kind, *realm.intrinsics().array_iterator_prototype());
 }

 ArrayIterator::ArrayIterator(Value array, Object::PropertyKind iteration_kind, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/AsyncFromSyncIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/AsyncFromSyncIterator.cpp
@ -13,7 +13,7 @@ namespace JS {

 NonnullGCPtr<AsyncFromSyncIterator> AsyncFromSyncIterator::create(Realm& realm, Iterator sync_iterator_record)
 {
-    return *realm.heap().allocate<AsyncFromSyncIterator>(realm, realm, sync_iterator_record);
+    return realm.heap().allocate<AsyncFromSyncIterator>(realm, realm, sync_iterator_record);
 }

 AsyncFromSyncIterator::AsyncFromSyncIterator(Realm& realm, Iterator sync_iterator_record)
--- a/Userland/Libraries/LibJS/Runtime/BigInt.cpp
+++ b/Userland/Libraries/LibJS/Runtime/BigInt.cpp
@ -13,7 +13,7 @@ namespace JS {

 NonnullGCPtr<BigInt> BigInt::create(VM& vm, Crypto::SignedBigInteger big_integer)
 {
-    return *vm.heap().allocate_without_realm<BigInt>(move(big_integer));
+    return vm.heap().allocate_without_realm<BigInt>(move(big_integer));
 }

 BigInt::BigInt(Crypto::SignedBigInteger big_integer)
--- a/Userland/Libraries/LibJS/Runtime/BigIntObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/BigIntObject.cpp
@ -11,7 +11,7 @@ namespace JS {

 NonnullGCPtr<BigIntObject> BigIntObject::create(Realm& realm, BigInt& bigint)
 {
-    return *realm.heap().allocate<BigIntObject>(realm, bigint, *realm.intrinsics().bigint_prototype());
+    return realm.heap().allocate<BigIntObject>(realm, bigint, *realm.intrinsics().bigint_prototype());
 }

 BigIntObject::BigIntObject(BigInt& bigint, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/BooleanObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/BooleanObject.cpp
@ -11,7 +11,7 @@ namespace JS {

 NonnullGCPtr<BooleanObject> BooleanObject::create(Realm& realm, bool value)
 {
-    return *realm.heap().allocate<BooleanObject>(realm, value, *realm.intrinsics().boolean_prototype());
+    return realm.heap().allocate<BooleanObject>(realm, value, *realm.intrinsics().boolean_prototype());
 }

 BooleanObject::BooleanObject(bool value, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/BoundFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/BoundFunction.cpp
@ -26,10 +26,10 @@ ThrowCompletionOr<NonnullGCPtr<BoundFunction>> BoundFunction::create(Realm& real
    // 7. Set obj.[[BoundTargetFunction]] to targetFunction.
    // 8. Set obj.[[BoundThis]] to boundThis.
    // 9. Set obj.[[BoundArguments]] to boundArgs.
-    auto* object = realm.heap().allocate<BoundFunction>(realm, realm, target_function, bound_this, move(bound_arguments), prototype);
+    auto object = realm.heap().allocate<BoundFunction>(realm, realm, target_function, bound_this, move(bound_arguments), prototype);

    // 10. Return obj.
-    return NonnullGCPtr { *object };
+    return object;
 }

 BoundFunction::BoundFunction(Realm& realm, FunctionObject& bound_target_function, Value bound_this, Vector<Value> bound_arguments, Object* prototype)
--- a/Userland/Libraries/LibJS/Runtime/DataView.cpp
+++ b/Userland/Libraries/LibJS/Runtime/DataView.cpp
@ -10,7 +10,7 @@ namespace JS {

 NonnullGCPtr<DataView> DataView::create(Realm& realm, ArrayBuffer* viewed_buffer, size_t byte_length, size_t byte_offset)
 {
-    return *realm.heap().allocate<DataView>(realm, viewed_buffer, byte_length, byte_offset, *realm.intrinsics().data_view_prototype());
+    return realm.heap().allocate<DataView>(realm, viewed_buffer, byte_length, byte_offset, *realm.intrinsics().data_view_prototype());
 }

 DataView::DataView(ArrayBuffer* viewed_buffer, size_t byte_length, size_t byte_offset, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Date.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Date.cpp
@ -23,7 +23,7 @@ static Crypto::SignedBigInteger const s_one_thousand_bigint { 1'000 };

 NonnullGCPtr<Date> Date::create(Realm& realm, double date_value)
 {
-    return *realm.heap().allocate<Date>(realm, date_value, *realm.intrinsics().date_prototype());
+    return realm.heap().allocate<Date>(realm, date_value, *realm.intrinsics().date_prototype());
 }

 Date::Date(double date_value, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
@ -45,12 +45,12 @@ NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& r
        prototype = realm.intrinsics().async_generator_function_prototype();
        break;
    }
-    return *realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, *prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name));
+    return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, *prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name));
 }

 NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, FlyString name, Object& prototype, DeprecatedString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
 {
-    return *realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name));
+    return realm.heap().allocate<ECMAScriptFunctionObject>(realm, move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, parent_environment, private_environment, prototype, kind, is_strict, might_need_arguments_object, contains_direct_call_to_eval, is_arrow_function, move(class_field_initializer_name));
 }

 ECMAScriptFunctionObject::ECMAScriptFunctionObject(FlyString name, DeprecatedString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> formal_parameters, i32 function_length, Environment* parent_environment, PrivateEnvironment* private_environment, Object& prototype, FunctionKind kind, bool strict, bool might_need_arguments_object, bool contains_direct_call_to_eval, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
--- a/Userland/Libraries/LibJS/Runtime/Error.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Error.cpp
@ -16,7 +16,7 @@ namespace JS {

 NonnullGCPtr<Error> Error::create(Realm& realm)
 {
-    return *realm.heap().allocate<Error>(realm, *realm.intrinsics().error_prototype());
+    return realm.heap().allocate<Error>(realm, *realm.intrinsics().error_prototype());
 }

 NonnullGCPtr<Error> Error::create(Realm& realm, DeprecatedString const& message)
@ -98,24 +98,24 @@ DeprecatedString Error::stack_string() const
    return stack_string_builder.build();
 }

-#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType)               \
-    NonnullGCPtr<ClassName> ClassName::create(Realm& realm)                                            \
-    {                                                                                                  \
-        return *realm.heap().allocate<ClassName>(realm, *realm.intrinsics().snake_name##_prototype()); \
-    }                                                                                                  \
-                                                                                                       \
-    NonnullGCPtr<ClassName> ClassName::create(Realm& realm, DeprecatedString const& message)           \
-    {                                                                                                  \
-        auto& vm = realm.vm();                                                                         \
-        auto error = ClassName::create(realm);                                                         \
-        u8 attr = Attribute::Writable | Attribute::Configurable;                                       \
-        error->define_direct_property(vm.names.message, PrimitiveString::create(vm, message), attr);   \
-        return error;                                                                                  \
-    }                                                                                                  \
-                                                                                                       \
-    ClassName::ClassName(Object& prototype)                                                            \
-        : Error(prototype)                                                                             \
-    {                                                                                                  \
+#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType)              \
+    NonnullGCPtr<ClassName> ClassName::create(Realm& realm)                                           \
+    {                                                                                                 \
+        return realm.heap().allocate<ClassName>(realm, *realm.intrinsics().snake_name##_prototype()); \
+    }                                                                                                 \
+                                                                                                      \
+    NonnullGCPtr<ClassName> ClassName::create(Realm& realm, DeprecatedString const& message)          \
+    {                                                                                                 \
+        auto& vm = realm.vm();                                                                        \
+        auto error = ClassName::create(realm);                                                        \
+        u8 attr = Attribute::Writable | Attribute::Configurable;                                      \
+        error->define_direct_property(vm.names.message, PrimitiveString::create(vm, message), attr);  \
+        return error;                                                                                 \
+    }                                                                                                 \
+                                                                                                      \
+    ClassName::ClassName(Object& prototype)                                                           \
+        : Error(prototype)                                                                            \
+    {                                                                                                 \
    }

 JS_ENUMERATE_NATIVE_ERRORS
--- a/Userland/Libraries/LibJS/Runtime/GeneratorObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/GeneratorObject.cpp
@ -32,7 +32,7 @@ ThrowCompletionOr<NonnullGCPtr<GeneratorObject>> GeneratorObject::create(Realm&
    object->m_generating_function = generating_function;
    object->m_frame = move(frame);
    object->m_previous_value = initial_value;
-    return NonnullGCPtr { *object };
+    return object;
 }

 GeneratorObject::GeneratorObject(Realm&, Object& prototype, ExecutionContext context)
--- a/Userland/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.cpp
@ -13,7 +13,7 @@ namespace JS::Intl {

 NonnullGCPtr<CollatorCompareFunction> CollatorCompareFunction::create(Realm& realm, Collator& collator)
 {
-    return *realm.heap().allocate<CollatorCompareFunction>(realm, realm, collator);
+    return realm.heap().allocate<CollatorCompareFunction>(realm, realm, collator);
 }

 CollatorCompareFunction::CollatorCompareFunction(Realm& realm, Collator& collator)
--- a/Userland/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.cpp
@ -16,7 +16,7 @@ namespace JS::Intl {
 // 11.5.5 DateTime Format Functions, https://tc39.es/ecma402/#sec-datetime-format-functions
 NonnullGCPtr<DateTimeFormatFunction> DateTimeFormatFunction::create(Realm& realm, DateTimeFormat& date_time_format)
 {
-    return *realm.heap().allocate<DateTimeFormatFunction>(realm, date_time_format, *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<DateTimeFormatFunction>(realm, date_time_format, *realm.intrinsics().function_prototype());
 }

 DateTimeFormatFunction::DateTimeFormatFunction(DateTimeFormat& date_time_format, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Intl/Locale.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intl/Locale.cpp
@ -16,7 +16,7 @@ namespace JS::Intl {

 NonnullGCPtr<Locale> Locale::create(Realm& realm, ::Locale::LocaleID const& locale_id)
 {
-    return *realm.heap().allocate<Locale>(realm, locale_id, *realm.intrinsics().intl_locale_prototype());
+    return realm.heap().allocate<Locale>(realm, locale_id, *realm.intrinsics().intl_locale_prototype());
 }

 // 14 Locale Objects, https://tc39.es/ecma402/#locale-objects
--- a/Userland/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.cpp
@ -14,7 +14,7 @@ namespace JS::Intl {
 // 1.1.4 Number Format Functions, https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-number-format-functions
 NonnullGCPtr<NumberFormatFunction> NumberFormatFunction::create(Realm& realm, NumberFormat& number_format)
 {
-    return *realm.heap().allocate<NumberFormatFunction>(realm, number_format, *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<NumberFormatFunction>(realm, number_format, *realm.intrinsics().function_prototype());
 }

 NumberFormatFunction::NumberFormatFunction(NumberFormat& number_format, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Intl/SegmentIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intl/SegmentIterator.cpp
@ -19,7 +19,7 @@ NonnullGCPtr<SegmentIterator> SegmentIterator::create(Realm& realm, Segmenter& s
    // 4. Set iterator.[[IteratedString]] to string.
    // 5. Set iterator.[[IteratedStringNextSegmentCodeUnitIndex]] to 0.
    // 6. Return iterator.
-    return *realm.heap().allocate<SegmentIterator>(realm, realm, segmenter, move(string), segments);
+    return realm.heap().allocate<SegmentIterator>(realm, realm, segmenter, move(string), segments);
 }

 // 18.6 Segment Iterator Objects, https://tc39.es/ecma402/#sec-segment-iterator-objects
--- a/Userland/Libraries/LibJS/Runtime/Intl/Segments.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intl/Segments.cpp
@ -18,7 +18,7 @@ NonnullGCPtr<Segments> Segments::create(Realm& realm, Segmenter& segmenter, Utf1
    // 3. Set segments.[[SegmentsSegmenter]] to segmenter.
    // 4. Set segments.[[SegmentsString]] to string.
    // 5. Return segments.
-    return *realm.heap().allocate<Segments>(realm, realm, segmenter, move(string));
+    return realm.heap().allocate<Segments>(realm, realm, segmenter, move(string));
 }

 // 18.5 Segments Objects, https://tc39.es/ecma402/#sec-segments-objects
--- a/Userland/Libraries/LibJS/Runtime/Intrinsics.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Intrinsics.cpp
@ -137,8 +137,8 @@ NonnullGCPtr<Intrinsics> Intrinsics::create(Realm& realm)
    auto& vm = realm.vm();

    // 1. Set realmRec.[[Intrinsics]] to a new Record.
-    auto* intrinsics = vm.heap().allocate_without_realm<Intrinsics>(realm);
-    realm.set_intrinsics({}, *intrinsics);
+    auto intrinsics = vm.heap().allocate_without_realm<Intrinsics>(realm);
+    realm.set_intrinsics({}, intrinsics);

    // 2. Set fields of realmRec.[[Intrinsics]] with the values listed in Table 6.
    //    The field names are the names listed in column one of the table.
--- a/Userland/Libraries/LibJS/Runtime/Map.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Map.cpp
@ -10,7 +10,7 @@ namespace JS {

 NonnullGCPtr<Map> Map::create(Realm& realm)
 {
-    return *realm.heap().allocate<Map>(realm, *realm.intrinsics().map_prototype());
+    return realm.heap().allocate<Map>(realm, *realm.intrinsics().map_prototype());
 }

 Map::Map(Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/MapIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/MapIterator.cpp
@ -11,7 +11,7 @@ namespace JS {

 NonnullGCPtr<MapIterator> MapIterator::create(Realm& realm, Map& map, Object::PropertyKind iteration_kind)
 {
-    return *realm.heap().allocate<MapIterator>(realm, map, iteration_kind, *realm.intrinsics().map_iterator_prototype());
+    return realm.heap().allocate<MapIterator>(realm, map, iteration_kind, *realm.intrinsics().map_iterator_prototype());
 }

 MapIterator::MapIterator(Map& map, Object::PropertyKind iteration_kind, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/NativeFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/NativeFunction.cpp
@ -36,7 +36,7 @@ NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& allocating_realm, Saf
    // 7. Set func.[[Extensible]] to true.
    // 8. Set func.[[Realm]] to realm.
    // 9. Set func.[[InitialName]] to null.
-    auto* function = allocating_realm.heap().allocate<NativeFunction>(allocating_realm, move(behaviour), prototype.value(), *realm.value());
+    auto function = allocating_realm.heap().allocate<NativeFunction>(allocating_realm, move(behaviour), prototype.value(), *realm.value());

    // 10. Perform SetFunctionLength(func, length).
    function->set_function_length(length);
@ -48,12 +48,12 @@ NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& allocating_realm, Saf
    function->set_function_name(name, prefix);

    // 13. Return func.
-    return *function;
+    return function;
 }

 NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& realm, FlyString const& name, SafeFunction<ThrowCompletionOr<Value>(VM&)> function)
 {
-    return *realm.heap().allocate<NativeFunction>(realm, name, move(function), *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<NativeFunction>(realm, name, move(function), *realm.intrinsics().function_prototype());
 }

 NativeFunction::NativeFunction(SafeFunction<ThrowCompletionOr<Value>(VM&)> native_function, Object* prototype, Realm& realm)
--- a/Userland/Libraries/LibJS/Runtime/NumberObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/NumberObject.cpp
@ -11,7 +11,7 @@ namespace JS {

 NonnullGCPtr<NumberObject> NumberObject::create(Realm& realm, double value)
 {
-    return *realm.heap().allocate<NumberObject>(realm, value, *realm.intrinsics().number_prototype());
+    return realm.heap().allocate<NumberObject>(realm, value, *realm.intrinsics().number_prototype());
 }

 NumberObject::NumberObject(double value, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Object.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Object.cpp
@ -30,11 +30,11 @@ static HashMap<Object const*, HashMap<FlyString, Object::IntrinsicAccessor>> s_i
 NonnullGCPtr<Object> Object::create(Realm& realm, Object* prototype)
 {
    if (!prototype)
-        return *realm.heap().allocate<Object>(realm, *realm.intrinsics().empty_object_shape());
+        return realm.heap().allocate<Object>(realm, *realm.intrinsics().empty_object_shape());
    else if (prototype == realm.intrinsics().object_prototype())
-        return *realm.heap().allocate<Object>(realm, *realm.intrinsics().new_object_shape());
+        return realm.heap().allocate<Object>(realm, *realm.intrinsics().new_object_shape());
    else
-        return *realm.heap().allocate<Object>(realm, ConstructWithPrototypeTag::Tag, *prototype);
+        return realm.heap().allocate<Object>(realm, ConstructWithPrototypeTag::Tag, *prototype);
 }

 Object::Object(GlobalObjectTag, Realm& realm)
--- a/Userland/Libraries/LibJS/Runtime/PrimitiveString.cpp
+++ b/Userland/Libraries/LibJS/Runtime/PrimitiveString.cpp
@ -125,7 +125,7 @@ NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, Utf16String string
            return vm.single_ascii_character_string(static_cast<u8>(code_unit));
    }

-    return *vm.heap().allocate_without_realm<PrimitiveString>(move(string));
+    return vm.heap().allocate_without_realm<PrimitiveString>(move(string));
 }

 NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, DeprecatedString string)
@ -142,7 +142,7 @@ NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, DeprecatedString s
    auto& string_cache = vm.string_cache();
    auto it = string_cache.find(string);
    if (it == string_cache.end()) {
-        auto* new_string = vm.heap().allocate_without_realm<PrimitiveString>(string);
+        auto new_string = vm.heap().allocate_without_realm<PrimitiveString>(string);
        string_cache.set(move(string), new_string);
        return *new_string;
    }
@ -166,7 +166,7 @@ NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, PrimitiveString& l
    if (rhs_empty)
        return lhs;

-    return *vm.heap().allocate_without_realm<PrimitiveString>(lhs, rhs);
+    return vm.heap().allocate_without_realm<PrimitiveString>(lhs, rhs);
 }

 void PrimitiveString::resolve_rope_if_needed() const
--- a/Userland/Libraries/LibJS/Runtime/Promise.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Promise.cpp
@ -44,7 +44,7 @@ ThrowCompletionOr<Object*> promise_resolve(VM& vm, Object& constructor, Value va

 NonnullGCPtr<Promise> Promise::create(Realm& realm)
 {
-    return *realm.heap().allocate<Promise>(realm, *realm.intrinsics().promise_prototype());
+    return realm.heap().allocate<Promise>(realm, *realm.intrinsics().promise_prototype());
 }

 // 27.2 Promise Objects, https://tc39.es/ecma262/#sec-promise-objects
@ -62,7 +62,7 @@ Promise::ResolvingFunctions Promise::create_resolving_functions()
    auto& realm = *vm.current_realm();

    // 1. Let alreadyResolved be the Record { [[Value]]: false }.
-    auto* already_resolved = vm.heap().allocate_without_realm<AlreadyResolved>();
+    auto already_resolved = vm.heap().allocate_without_realm<AlreadyResolved>();

    // 2. Let stepsResolve be the algorithm steps defined in Promise Resolve Functions.
    // 3. Let lengthResolve be the number of non-optional parameters of the function definition in Promise Resolve Functions.
--- a/Userland/Libraries/LibJS/Runtime/PromiseCapability.cpp
+++ b/Userland/Libraries/LibJS/Runtime/PromiseCapability.cpp
@ -13,7 +13,7 @@ namespace JS {

 NonnullGCPtr<PromiseCapability> PromiseCapability::create(VM& vm, GCPtr<Object> promise, GCPtr<FunctionObject> resolve, GCPtr<FunctionObject> reject)
 {
-    return NonnullGCPtr { *vm.heap().allocate_without_realm<PromiseCapability>(promise, resolve, reject) };
+    return vm.heap().allocate_without_realm<PromiseCapability>(promise, resolve, reject);
 }

 PromiseCapability::PromiseCapability(GCPtr<Object> promise, GCPtr<FunctionObject> resolve, GCPtr<FunctionObject> reject)
--- a/Userland/Libraries/LibJS/Runtime/PromiseConstructor.cpp
+++ b/Userland/Libraries/LibJS/Runtime/PromiseConstructor.cpp
@ -45,10 +45,10 @@ static ThrowCompletionOr<Value> perform_promise_common(VM& vm, Iterator& iterato
    VERIFY(promise_resolve.is_function());

    // 1. Let values be a new empty List.
-    auto* values = vm.heap().allocate_without_realm<PromiseValueList>();
+    auto values = vm.heap().allocate_without_realm<PromiseValueList>();

    // 2. Let remainingElementsCount be the Record { [[Value]]: 1 }.
-    auto* remaining_elements_count = vm.heap().allocate_without_realm<RemainingElements>(1);
+    auto remaining_elements_count = vm.heap().allocate_without_realm<RemainingElements>(1);

    // 3. Let index be 0.
    size_t index = 0;
--- a/Userland/Libraries/LibJS/Runtime/PromiseReaction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/PromiseReaction.cpp
@ -12,7 +12,7 @@ namespace JS {

 NonnullGCPtr<PromiseReaction> PromiseReaction::create(VM& vm, Type type, GCPtr<PromiseCapability> capability, Optional<JobCallback> handler)
 {
-    return *vm.heap().allocate_without_realm<PromiseReaction>(type, capability, move(handler));
+    return vm.heap().allocate_without_realm<PromiseReaction>(type, capability, move(handler));
 }

 PromiseReaction::PromiseReaction(Type type, GCPtr<PromiseCapability> capability, Optional<JobCallback> handler)
--- a/Userland/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.cpp
+++ b/Userland/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.cpp
@ -55,7 +55,7 @@ void PromiseResolvingElementFunction::visit_edges(Cell::Visitor& visitor)

 NonnullGCPtr<PromiseAllResolveElementFunction> PromiseAllResolveElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements)
 {
-    return *realm.heap().allocate<PromiseAllResolveElementFunction>(realm, index, values, capability, remaining_elements, *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<PromiseAllResolveElementFunction>(realm, index, values, capability, remaining_elements, *realm.intrinsics().function_prototype());
 }

 PromiseAllResolveElementFunction::PromiseAllResolveElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements, Object& prototype)
@ -87,7 +87,7 @@ ThrowCompletionOr<Value> PromiseAllResolveElementFunction::resolve_element()

 NonnullGCPtr<PromiseAllSettledResolveElementFunction> PromiseAllSettledResolveElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements)
 {
-    return *realm.heap().allocate<PromiseAllSettledResolveElementFunction>(realm, index, values, capability, remaining_elements, *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<PromiseAllSettledResolveElementFunction>(realm, index, values, capability, remaining_elements, *realm.intrinsics().function_prototype());
 }

 PromiseAllSettledResolveElementFunction::PromiseAllSettledResolveElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements, Object& prototype)
@ -128,7 +128,7 @@ ThrowCompletionOr<Value> PromiseAllSettledResolveElementFunction::resolve_elemen

 NonnullGCPtr<PromiseAllSettledRejectElementFunction> PromiseAllSettledRejectElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements)
 {
-    return *realm.heap().allocate<PromiseAllSettledRejectElementFunction>(realm, index, values, capability, remaining_elements, *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<PromiseAllSettledRejectElementFunction>(realm, index, values, capability, remaining_elements, *realm.intrinsics().function_prototype());
 }

 PromiseAllSettledRejectElementFunction::PromiseAllSettledRejectElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements, Object& prototype)
@ -169,7 +169,7 @@ ThrowCompletionOr<Value> PromiseAllSettledRejectElementFunction::resolve_element

 NonnullGCPtr<PromiseAnyRejectElementFunction> PromiseAnyRejectElementFunction::create(Realm& realm, size_t index, PromiseValueList& errors, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements)
 {
-    return *realm.heap().allocate<PromiseAnyRejectElementFunction>(realm, index, errors, capability, remaining_elements, *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<PromiseAnyRejectElementFunction>(realm, index, errors, capability, remaining_elements, *realm.intrinsics().function_prototype());
 }

 PromiseAnyRejectElementFunction::PromiseAnyRejectElementFunction(size_t index, PromiseValueList& errors, NonnullGCPtr<PromiseCapability> capability, RemainingElements& remaining_elements, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/PromiseResolvingFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/PromiseResolvingFunction.cpp
@ -13,7 +13,7 @@ namespace JS {

 NonnullGCPtr<PromiseResolvingFunction> PromiseResolvingFunction::create(Realm& realm, Promise& promise, AlreadyResolved& already_resolved, FunctionType function)
 {
-    return *realm.heap().allocate<PromiseResolvingFunction>(realm, promise, already_resolved, move(function), *realm.intrinsics().function_prototype());
+    return realm.heap().allocate<PromiseResolvingFunction>(realm, promise, already_resolved, move(function), *realm.intrinsics().function_prototype());
 }

 PromiseResolvingFunction::PromiseResolvingFunction(Promise& promise, AlreadyResolved& already_resolved, FunctionType native_function, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/ProxyObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/ProxyObject.cpp
@ -17,7 +17,7 @@ namespace JS {

 NonnullGCPtr<ProxyObject> ProxyObject::create(Realm& realm, Object& target, Object& handler)
 {
-    return *realm.heap().allocate<ProxyObject>(realm, target, handler, *realm.intrinsics().object_prototype());
+    return realm.heap().allocate<ProxyObject>(realm, target, handler, *realm.intrinsics().object_prototype());
 }

 ProxyObject::ProxyObject(Object& target, Object& handler, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Realm.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Realm.cpp
@ -18,7 +18,7 @@ namespace JS {
 NonnullGCPtr<Realm> Realm::create(VM& vm)
 {
    // 1. Let realmRec be a new Realm Record.
-    auto* realm = vm.heap().allocate_without_realm<Realm>();
+    auto realm = vm.heap().allocate_without_realm<Realm>();

    // 2. Perform CreateIntrinsics(realmRec).
    Intrinsics::create(*realm);
@ -28,7 +28,7 @@ NonnullGCPtr<Realm> Realm::create(VM& vm)
    // 5. Set realmRec.[[TemplateMap]] to a new empty List.

    // 6. Return realmRec.
-    return *realm;
+    return realm;
 }

 // 9.6 InitializeHostDefinedRealm ( ), https://tc39.es/ecma262/#sec-initializehostdefinedrealm
--- a/Userland/Libraries/LibJS/Runtime/RegExpObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/RegExpObject.cpp
@ -126,12 +126,12 @@ ThrowCompletionOr<DeprecatedString> parse_regex_pattern(VM& vm, StringView patte

 NonnullGCPtr<RegExpObject> RegExpObject::create(Realm& realm)
 {
-    return *realm.heap().allocate<RegExpObject>(realm, *realm.intrinsics().regexp_prototype());
+    return realm.heap().allocate<RegExpObject>(realm, *realm.intrinsics().regexp_prototype());
 }

 NonnullGCPtr<RegExpObject> RegExpObject::create(Realm& realm, Regex<ECMA262> regex, DeprecatedString pattern, DeprecatedString flags)
 {
-    return *realm.heap().allocate<RegExpObject>(realm, move(regex), move(pattern), move(flags), *realm.intrinsics().regexp_prototype());
+    return realm.heap().allocate<RegExpObject>(realm, move(regex), move(pattern), move(flags), *realm.intrinsics().regexp_prototype());
 }

 RegExpObject::RegExpObject(Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/RegExpStringIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/RegExpStringIterator.cpp
@ -12,7 +12,7 @@ namespace JS {
 // 22.2.7.1 CreateRegExpStringIterator ( R, S, global, fullUnicode ), https://tc39.es/ecma262/#sec-createregexpstringiterator
 NonnullGCPtr<RegExpStringIterator> RegExpStringIterator::create(Realm& realm, Object& regexp_object, Utf16String string, bool global, bool unicode)
 {
-    return *realm.heap().allocate<RegExpStringIterator>(realm, *realm.intrinsics().regexp_string_iterator_prototype(), regexp_object, move(string), global, unicode);
+    return realm.heap().allocate<RegExpStringIterator>(realm, *realm.intrinsics().regexp_string_iterator_prototype(), regexp_object, move(string), global, unicode);
 }

 RegExpStringIterator::RegExpStringIterator(Object& prototype, Object& regexp_object, Utf16String string, bool global, bool unicode)
--- a/Userland/Libraries/LibJS/Runtime/Set.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Set.cpp
@ -10,7 +10,7 @@ namespace JS {

 NonnullGCPtr<Set> Set::create(Realm& realm)
 {
-    return *realm.heap().allocate<Set>(realm, *realm.intrinsics().set_prototype());
+    return realm.heap().allocate<Set>(realm, *realm.intrinsics().set_prototype());
 }

 Set::Set(Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/SetIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/SetIterator.cpp
@ -11,7 +11,7 @@ namespace JS {

 NonnullGCPtr<SetIterator> SetIterator::create(Realm& realm, Set& set, Object::PropertyKind iteration_kind)
 {
-    return *realm.heap().allocate<SetIterator>(realm, set, iteration_kind, *realm.intrinsics().set_iterator_prototype());
+    return realm.heap().allocate<SetIterator>(realm, set, iteration_kind, *realm.intrinsics().set_iterator_prototype());
 }

 SetIterator::SetIterator(Set& set, Object::PropertyKind iteration_kind, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Shape.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Shape.cpp
@ -12,7 +12,7 @@ namespace JS {

 Shape* Shape::create_unique_clone() const
 {
-    auto* new_shape = heap().allocate_without_realm<Shape>(m_realm);
+    auto new_shape = heap().allocate_without_realm<Shape>(m_realm);
    new_shape->m_unique = true;
    new_shape->m_prototype = m_prototype;
    ensure_property_table();
@ -57,10 +57,10 @@ Shape* Shape::create_put_transition(StringOrSymbol const& property_key, Property
    TransitionKey key { property_key, attributes };
    if (auto* existing_shape = get_or_prune_cached_forward_transition(key))
        return existing_shape;
-    auto* new_shape = heap().allocate_without_realm<Shape>(*this, property_key, attributes, TransitionType::Put);
+    auto new_shape = heap().allocate_without_realm<Shape>(*this, property_key, attributes, TransitionType::Put);
    if (!m_forward_transitions)
        m_forward_transitions = make<HashMap<TransitionKey, WeakPtr<Shape>>>();
-    m_forward_transitions->set(key, new_shape);
+    m_forward_transitions->set(key, new_shape.ptr());
    return new_shape;
 }

@ -69,10 +69,10 @@ Shape* Shape::create_configure_transition(StringOrSymbol const& property_key, Pr
    TransitionKey key { property_key, attributes };
    if (auto* existing_shape = get_or_prune_cached_forward_transition(key))
        return existing_shape;
-    auto* new_shape = heap().allocate_without_realm<Shape>(*this, property_key, attributes, TransitionType::Configure);
+    auto new_shape = heap().allocate_without_realm<Shape>(*this, property_key, attributes, TransitionType::Configure);
    if (!m_forward_transitions)
        m_forward_transitions = make<HashMap<TransitionKey, WeakPtr<Shape>>>();
-    m_forward_transitions->set(key, new_shape);
+    m_forward_transitions->set(key, new_shape.ptr());
    return new_shape;
 }

@ -80,10 +80,10 @@ Shape* Shape::create_prototype_transition(Object* new_prototype)
 {
    if (auto* existing_shape = get_or_prune_cached_prototype_transition(new_prototype))
        return existing_shape;
-    auto* new_shape = heap().allocate_without_realm<Shape>(*this, new_prototype);
+    auto new_shape = heap().allocate_without_realm<Shape>(*this, new_prototype);
    if (!m_prototype_transitions)
        m_prototype_transitions = make<HashMap<Object*, WeakPtr<Shape>>>();
-    m_prototype_transitions->set(new_prototype, new_shape);
+    m_prototype_transitions->set(new_prototype, new_shape.ptr());
    return new_shape;
 }

--- a/Userland/Libraries/LibJS/Runtime/StringIterator.cpp
+++ b/Userland/Libraries/LibJS/Runtime/StringIterator.cpp
@ -12,7 +12,7 @@ namespace JS {

 NonnullGCPtr<StringIterator> StringIterator::create(Realm& realm, DeprecatedString string)
 {
-    return *realm.heap().allocate<StringIterator>(realm, move(string), *realm.intrinsics().string_iterator_prototype());
+    return realm.heap().allocate<StringIterator>(realm, move(string), *realm.intrinsics().string_iterator_prototype());
 }

 StringIterator::StringIterator(DeprecatedString string, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/StringObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/StringObject.cpp
@ -17,7 +17,7 @@ namespace JS {
 // 10.4.3.4 StringCreate ( value, prototype ), https://tc39.es/ecma262/#sec-stringcreate
 NonnullGCPtr<StringObject> StringObject::create(Realm& realm, PrimitiveString& primitive_string, Object& prototype)
 {
-    return *realm.heap().allocate<StringObject>(realm, primitive_string, prototype);
+    return realm.heap().allocate<StringObject>(realm, primitive_string, prototype);
 }

 StringObject::StringObject(PrimitiveString& string, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/Symbol.cpp
+++ b/Userland/Libraries/LibJS/Runtime/Symbol.cpp
@ -19,7 +19,7 @@ Symbol::Symbol(Optional<DeprecatedString> description, bool is_global)

 NonnullGCPtr<Symbol> Symbol::create(VM& vm, Optional<DeprecatedString> description, bool is_global)
 {
-    return *vm.heap().allocate_without_realm<Symbol>(move(description), is_global);
+    return vm.heap().allocate_without_realm<Symbol>(move(description), is_global);
 }

 }
--- a/Userland/Libraries/LibJS/Runtime/SymbolObject.cpp
+++ b/Userland/Libraries/LibJS/Runtime/SymbolObject.cpp
@ -12,7 +12,7 @@ namespace JS {

 NonnullGCPtr<SymbolObject> SymbolObject::create(Realm& realm, Symbol& primitive_symbol)
 {
-    return *realm.heap().allocate<SymbolObject>(realm, primitive_symbol, *realm.intrinsics().symbol_prototype());
+    return realm.heap().allocate<SymbolObject>(realm, primitive_symbol, *realm.intrinsics().symbol_prototype());
 }

 SymbolObject::SymbolObject(Symbol& symbol, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/TypedArray.cpp
+++ b/Userland/Libraries/LibJS/Runtime/TypedArray.cpp
@ -425,7 +425,7 @@ void TypedArrayBase::visit_edges(Visitor& visitor)
    {                                                                                                                            \
        auto* prototype = TRY(get_prototype_from_constructor(realm.vm(), new_target, &Intrinsics::snake_name##_prototype));      \
        auto array_buffer = TRY(ArrayBuffer::create(realm, length * sizeof(UnderlyingBufferDataType)));                          \
-        return NonnullGCPtr { *realm.heap().allocate<ClassName>(realm, *prototype, length, *array_buffer) };                     \
+        return realm.heap().allocate<ClassName>(realm, *prototype, length, *array_buffer);                                       \
    }                                                                                                                            \
                                                                                                                                 \
    ThrowCompletionOr<NonnullGCPtr<ClassName>> ClassName::create(Realm& realm, u32 length)                                       \
@ -436,7 +436,7 @@ void TypedArrayBase::visit_edges(Visitor& visitor)
                                                                                                                                 \
    NonnullGCPtr<ClassName> ClassName::create(Realm& realm, u32 length, ArrayBuffer& array_buffer)                               \
    {                                                                                                                            \
-        return *realm.heap().allocate<ClassName>(realm, *realm.intrinsics().snake_name##_prototype(), length, array_buffer);     \
+        return realm.heap().allocate<ClassName>(realm, *realm.intrinsics().snake_name##_prototype(), length, array_buffer);      \
    }                                                                                                                            \
                                                                                                                                 \
    ClassName::ClassName(Object& prototype, u32 length, ArrayBuffer& array_buffer)                                               \
--- a/Userland/Libraries/LibJS/Runtime/WeakMap.cpp
+++ b/Userland/Libraries/LibJS/Runtime/WeakMap.cpp
@ -10,7 +10,7 @@ namespace JS {

 NonnullGCPtr<WeakMap> WeakMap::create(Realm& realm)
 {
-    return *realm.heap().allocate<WeakMap>(realm, *realm.intrinsics().weak_map_prototype());
+    return realm.heap().allocate<WeakMap>(realm, *realm.intrinsics().weak_map_prototype());
 }

 WeakMap::WeakMap(Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/WeakRef.cpp
+++ b/Userland/Libraries/LibJS/Runtime/WeakRef.cpp
@ -10,12 +10,12 @@ namespace JS {

 NonnullGCPtr<WeakRef> WeakRef::create(Realm& realm, Object& value)
 {
-    return *realm.heap().allocate<WeakRef>(realm, value, *realm.intrinsics().weak_ref_prototype());
+    return realm.heap().allocate<WeakRef>(realm, value, *realm.intrinsics().weak_ref_prototype());
 }

 NonnullGCPtr<WeakRef> WeakRef::create(Realm& realm, Symbol& value)
 {
-    return *realm.heap().allocate<WeakRef>(realm, value, *realm.intrinsics().weak_ref_prototype());
+    return realm.heap().allocate<WeakRef>(realm, value, *realm.intrinsics().weak_ref_prototype());
 }

 WeakRef::WeakRef(Object& value, Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/WeakSet.cpp
+++ b/Userland/Libraries/LibJS/Runtime/WeakSet.cpp
@ -10,7 +10,7 @@ namespace JS {

 NonnullGCPtr<WeakSet> WeakSet::create(Realm& realm)
 {
-    return *realm.heap().allocate<WeakSet>(realm, *realm.intrinsics().weak_set_prototype());
+    return realm.heap().allocate<WeakSet>(realm, *realm.intrinsics().weak_set_prototype());
 }

 WeakSet::WeakSet(Object& prototype)
--- a/Userland/Libraries/LibJS/Runtime/WrappedFunction.cpp
+++ b/Userland/Libraries/LibJS/Runtime/WrappedFunction.cpp
@ -22,7 +22,7 @@ ThrowCompletionOr<NonnullGCPtr<WrappedFunction>> WrappedFunction::create(Realm&
    // 5. Set wrapped.[[WrappedTargetFunction]] to Target.
    // 6. Set wrapped.[[Realm]] to callerRealm.
    auto& prototype = *caller_realm.intrinsics().function_prototype();
-    auto* wrapped = vm.heap().allocate<WrappedFunction>(realm, caller_realm, target, prototype);
+    auto wrapped = vm.heap().allocate<WrappedFunction>(realm, caller_realm, target, prototype);

    // 7. Let result be CopyNameAndLength(wrapped, Target).
    auto result = copy_name_and_length(vm, *wrapped, target);
@ -32,7 +32,7 @@ ThrowCompletionOr<NonnullGCPtr<WrappedFunction>> WrappedFunction::create(Realm&
        return vm.throw_completion<TypeError>(ErrorType::WrappedFunctionCopyNameAndLengthThrowCompletion);

    // 9. Return wrapped.
-    return NonnullGCPtr { *wrapped };
+    return wrapped;
 }

 // 2 Wrapped Function Exotic Objects, https://tc39.es/proposal-shadowrealm/#sec-wrapped-function-exotic-objects
--- a/Userland/Libraries/LibJS/Script.cpp
+++ b/Userland/Libraries/LibJS/Script.cpp
@ -24,7 +24,7 @@ Result<NonnullGCPtr<Script>, Vector<ParserError>> Script::parse(StringView sourc
        return parser.errors();

    // 3. Return Script Record { [[Realm]]: realm, [[ECMAScriptCode]]: script, [[HostDefined]]: hostDefined }.
-    return NonnullGCPtr(*realm.heap().allocate_without_realm<Script>(realm, filename, move(script), host_defined));
+    return realm.heap().allocate_without_realm<Script>(realm, filename, move(script), host_defined);
 }

 Script::Script(Realm& realm, StringView filename, NonnullRefPtr<Program> parse_node, HostDefined* host_defined)
--- a/Userland/Libraries/LibJS/SourceTextModule.cpp
+++ b/Userland/Libraries/LibJS/SourceTextModule.cpp
@ -244,7 +244,7 @@ Result<NonnullGCPtr<SourceTextModule>, Vector<ParserError>> SourceTextModule::pa
    //          [[HostDefined]]: hostDefined, [[ECMAScriptCode]]: body, [[Context]]: empty, [[ImportMeta]]: empty,
    //          [[RequestedModules]]: requestedModules, [[ImportEntries]]: importEntries, [[LocalExportEntries]]: localExportEntries,
    //          [[IndirectExportEntries]]: indirectExportEntries, [[StarExportEntries]]: starExportEntries, [[DFSIndex]]: empty, [[DFSAncestorIndex]]: empty }.
-    return NonnullGCPtr(*realm.heap().allocate_without_realm<SourceTextModule>(
+    return realm.heap().allocate_without_realm<SourceTextModule>(
        realm,
        filename,
        host_defined,
@ -255,7 +255,7 @@ Result<NonnullGCPtr<SourceTextModule>, Vector<ParserError>> SourceTextModule::pa
        move(local_export_entries),
        move(indirect_export_entries),
        move(star_export_entries),
-        move(default_export)));
+        move(default_export));
 }

 // 16.2.1.6.2 GetExportedNames ( [ exportStarSet ] ), https://tc39.es/ecma262/#sec-getexportednames
@ -347,7 +347,7 @@ ThrowCompletionOr<void> SourceTextModule::initialize_environment(VM& vm)
    // Note: This must be true because we use a reference.

    // 5. Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
-    auto* environment = vm.heap().allocate_without_realm<ModuleEnvironment>(&realm().global_environment());
+    auto environment = vm.heap().allocate_without_realm<ModuleEnvironment>(&realm().global_environment());

    // 6. Set module.[[Environment]] to env.
    set_environment(environment);
--- a/Userland/Libraries/LibJS/SyntheticModule.cpp
+++ b/Userland/Libraries/LibJS/SyntheticModule.cpp
@ -51,7 +51,7 @@ ThrowCompletionOr<void> SyntheticModule::link(VM& vm)
    // Note: This must be true because we use a reference.

    // 3. Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
-    auto* environment = vm.heap().allocate_without_realm<ModuleEnvironment>(&realm().global_environment());
+    auto environment = vm.heap().allocate_without_realm<ModuleEnvironment>(&realm().global_environment());

    // 4. Set module.[[Environment]] to env.
    set_environment(environment);
@ -139,7 +139,7 @@ NonnullGCPtr<SyntheticModule> SyntheticModule::create_default_export_synthetic_m
    };

    // 2. Return CreateSyntheticModule("default", closure, realm)
-    return *realm.heap().allocate_without_realm<SyntheticModule>(Vector<FlyString> { "default" }, move(closure), realm, filename);
+    return realm.heap().allocate_without_realm<SyntheticModule>(Vector<FlyString> { "default" }, move(closure), realm, filename);
 }

 // 1.4 ParseJSONModule ( source ), https://tc39.es/proposal-json-modules/#sec-parse-json-module