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

2025-07-28 05:27:45 +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/LibWeb/DOM/AbortController.cpp
+++ b/Userland/Libraries/LibWeb/DOM/AbortController.cpp
@ -13,7 +13,7 @@ namespace Web::DOM {
 JS::NonnullGCPtr<AbortController> AbortController::construct_impl(JS::Realm& realm)
 {
    auto signal = AbortSignal::construct_impl(realm);
-    return *realm.heap().allocate<AbortController>(realm, realm, move(signal));
+    return realm.heap().allocate<AbortController>(realm, realm, move(signal));
 }

 // https://dom.spec.whatwg.org/#dom-abortcontroller-abortcontroller
--- a/Userland/Libraries/LibWeb/DOM/AbortSignal.cpp
+++ b/Userland/Libraries/LibWeb/DOM/AbortSignal.cpp
@ -14,7 +14,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<AbortSignal> AbortSignal::construct_impl(JS::Realm& realm)
 {
-    return *realm.heap().allocate<AbortSignal>(realm, realm);
+    return realm.heap().allocate<AbortSignal>(realm, realm);
 }

 AbortSignal::AbortSignal(JS::Realm& realm)
--- a/Userland/Libraries/LibWeb/DOM/Attr.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Attr.cpp
@ -15,7 +15,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<Attr> Attr::create(Document& document, FlyString local_name, DeprecatedString value, Element const* owner_element)
 {
-    return *document.heap().allocate<Attr>(document.realm(), document, QualifiedName(move(local_name), {}, {}), move(value), owner_element);
+    return document.heap().allocate<Attr>(document.realm(), document, QualifiedName(move(local_name), {}, {}), move(value), owner_element);
 }

 JS::NonnullGCPtr<Attr> Attr::clone(Document& document)
--- a/Userland/Libraries/LibWeb/DOM/Comment.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Comment.cpp
@ -19,7 +19,7 @@ Comment::Comment(Document& document, DeprecatedString const& data)
 JS::NonnullGCPtr<Comment> Comment::construct_impl(JS::Realm& realm, DeprecatedString const& data)
 {
    auto& window = verify_cast<HTML::Window>(realm.global_object());
-    return *realm.heap().allocate<Comment>(realm, window.associated_document(), data);
+    return realm.heap().allocate<Comment>(realm, window.associated_document(), data);
 }

 }
--- a/Userland/Libraries/LibWeb/DOM/DOMImplementation.cpp
+++ b/Userland/Libraries/LibWeb/DOM/DOMImplementation.cpp
@ -20,7 +20,7 @@ namespace Web::DOM {
 JS::NonnullGCPtr<DOMImplementation> DOMImplementation::create(Document& document)
 {
    auto& realm = document.realm();
-    return *realm.heap().allocate<DOMImplementation>(realm, document);
+    return realm.heap().allocate<DOMImplementation>(realm, document);
 }

 DOMImplementation::DOMImplementation(Document& document)
--- a/Userland/Libraries/LibWeb/DOM/Document.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Document.cpp
@ -289,7 +289,7 @@ JS::NonnullGCPtr<Document> Document::construct_impl(JS::Realm& realm)

 JS::NonnullGCPtr<Document> Document::create(JS::Realm& realm, AK::URL const& url)
 {
-    return *realm.heap().allocate<Document>(realm, realm, url);
+    return realm.heap().allocate<Document>(realm, realm, url);
 }

 Document::Document(JS::Realm& realm, const AK::URL& url)
@ -680,7 +680,7 @@ void Document::set_title(DeprecatedString const& title)
    }

    title_element->remove_all_children(true);
-    MUST(title_element->append_child(*heap().allocate<Text>(realm(), *this, title)));
+    MUST(title_element->append_child(heap().allocate<Text>(realm(), *this, title)));

    if (auto* page = this->page()) {
        if (browsing_context() == &page->top_level_browsing_context())
@ -1221,17 +1221,17 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> Document::create_element_ns(Depre

 JS::NonnullGCPtr<DocumentFragment> Document::create_document_fragment()
 {
-    return *heap().allocate<DocumentFragment>(realm(), *this);
+    return heap().allocate<DocumentFragment>(realm(), *this);
 }

 JS::NonnullGCPtr<Text> Document::create_text_node(DeprecatedString const& data)
 {
-    return *heap().allocate<Text>(realm(), *this, data);
+    return heap().allocate<Text>(realm(), *this, data);
 }

 JS::NonnullGCPtr<Comment> Document::create_comment(DeprecatedString const& data)
 {
-    return *heap().allocate<Comment>(realm(), *this, data);
+    return heap().allocate<Comment>(realm(), *this, data);
 }

 // https://dom.spec.whatwg.org/#dom-document-createprocessinginstruction
--- a/Userland/Libraries/LibWeb/DOM/DocumentFragment.cpp
+++ b/Userland/Libraries/LibWeb/DOM/DocumentFragment.cpp
@ -30,7 +30,7 @@ void DocumentFragment::set_host(Web::DOM::Element* element)
 JS::NonnullGCPtr<DocumentFragment> DocumentFragment::construct_impl(JS::Realm& realm)
 {
    auto& window = verify_cast<HTML::Window>(realm.global_object());
-    return *realm.heap().allocate<DocumentFragment>(realm, window.associated_document());
+    return realm.heap().allocate<DocumentFragment>(realm, window.associated_document());
 }

 }
--- a/Userland/Libraries/LibWeb/DOM/DocumentType.cpp
+++ b/Userland/Libraries/LibWeb/DOM/DocumentType.cpp
@ -11,7 +11,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<DocumentType> DocumentType::create(Document& document)
 {
-    return *document.heap().allocate<DocumentType>(document.realm(), document);
+    return document.heap().allocate<DocumentType>(document.realm(), document);
 }

 DocumentType::DocumentType(Document& document)
--- a/Userland/Libraries/LibWeb/DOM/Element.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Element.cpp
@ -1174,11 +1174,11 @@ WebIDL::ExceptionOr<JS::GCPtr<Element>> Element::insert_adjacent_element(Depreca
 WebIDL::ExceptionOr<void> Element::insert_adjacent_text(DeprecatedString const& where, DeprecatedString const& data)
 {
    // 1. Let text be a new Text node whose data is data and node document is this’s node document.
-    JS::NonnullGCPtr<Text> text = *heap().allocate<DOM::Text>(realm(), document(), data);
+    auto text = heap().allocate<DOM::Text>(realm(), document(), data);

    // 2. Run insert adjacent, given this, where, and text.
    // Spec Note: This method returns nothing because it existed before we had a chance to design it.
-    (void)TRY(insert_adjacent(where, move(text)));
+    (void)TRY(insert_adjacent(where, text));
    return {};
 }

--- a/Userland/Libraries/LibWeb/DOM/ElementFactory.cpp
+++ b/Userland/Libraries/LibWeb/DOM/ElementFactory.cpp
@ -120,180 +120,180 @@ JS::NonnullGCPtr<Element> create_element(Document& document, FlyString local_nam

    auto qualified_name = QualifiedName { local_name, prefix, namespace_ };
    if (lowercase_tag_name == HTML::TagNames::a)
-        return *realm.heap().allocate<HTML::HTMLAnchorElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLAnchorElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::area)
-        return *realm.heap().allocate<HTML::HTMLAreaElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLAreaElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::audio)
-        return *realm.heap().allocate<HTML::HTMLAudioElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLAudioElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::base)
-        return *realm.heap().allocate<HTML::HTMLBaseElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLBaseElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::blink)
-        return *realm.heap().allocate<HTML::HTMLBlinkElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLBlinkElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::body)
-        return *realm.heap().allocate<HTML::HTMLBodyElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLBodyElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::br)
-        return *realm.heap().allocate<HTML::HTMLBRElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLBRElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::button)
-        return *realm.heap().allocate<HTML::HTMLButtonElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLButtonElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::canvas)
-        return *realm.heap().allocate<HTML::HTMLCanvasElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLCanvasElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::data)
-        return *realm.heap().allocate<HTML::HTMLDataElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDataElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::datalist)
-        return *realm.heap().allocate<HTML::HTMLDataListElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDataListElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::details)
-        return *realm.heap().allocate<HTML::HTMLDetailsElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDetailsElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::dialog)
-        return *realm.heap().allocate<HTML::HTMLDialogElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDialogElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::dir)
-        return *realm.heap().allocate<HTML::HTMLDirectoryElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDirectoryElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::div)
-        return *realm.heap().allocate<HTML::HTMLDivElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDivElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::dl)
-        return *realm.heap().allocate<HTML::HTMLDListElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLDListElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::embed)
-        return *realm.heap().allocate<HTML::HTMLEmbedElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLEmbedElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::fieldset)
-        return *realm.heap().allocate<HTML::HTMLFieldSetElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLFieldSetElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::font)
-        return *realm.heap().allocate<HTML::HTMLFontElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLFontElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::form)
-        return *realm.heap().allocate<HTML::HTMLFormElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLFormElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::frame)
-        return *realm.heap().allocate<HTML::HTMLFrameElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLFrameElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::frameset)
-        return *realm.heap().allocate<HTML::HTMLFrameSetElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLFrameSetElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::head)
-        return *realm.heap().allocate<HTML::HTMLHeadElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLHeadElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6))
-        return *realm.heap().allocate<HTML::HTMLHeadingElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLHeadingElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::hr)
-        return *realm.heap().allocate<HTML::HTMLHRElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLHRElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::html)
-        return *realm.heap().allocate<HTML::HTMLHtmlElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLHtmlElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::iframe)
-        return *realm.heap().allocate<HTML::HTMLIFrameElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLIFrameElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::img)
-        return *realm.heap().allocate<HTML::HTMLImageElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLImageElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::input)
-        return *realm.heap().allocate<HTML::HTMLInputElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLInputElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::label)
-        return *realm.heap().allocate<HTML::HTMLLabelElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLLabelElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::legend)
-        return *realm.heap().allocate<HTML::HTMLLegendElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLLegendElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::li)
-        return *realm.heap().allocate<HTML::HTMLLIElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLLIElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::link)
-        return *realm.heap().allocate<HTML::HTMLLinkElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLLinkElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::map)
-        return *realm.heap().allocate<HTML::HTMLMapElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLMapElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::marquee)
-        return *realm.heap().allocate<HTML::HTMLMarqueeElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLMarqueeElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::menu)
-        return *realm.heap().allocate<HTML::HTMLMenuElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLMenuElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::meta)
-        return *realm.heap().allocate<HTML::HTMLMetaElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLMetaElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::meter)
-        return *realm.heap().allocate<HTML::HTMLMeterElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLMeterElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(HTML::TagNames::ins, HTML::TagNames::del))
-        return *realm.heap().allocate<HTML::HTMLModElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLModElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::object)
-        return *realm.heap().allocate<HTML::HTMLObjectElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLObjectElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::ol)
-        return *realm.heap().allocate<HTML::HTMLOListElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLOListElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::optgroup)
-        return *realm.heap().allocate<HTML::HTMLOptGroupElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLOptGroupElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::option)
-        return *realm.heap().allocate<HTML::HTMLOptionElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLOptionElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::output)
-        return *realm.heap().allocate<HTML::HTMLOutputElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLOutputElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::p)
-        return *realm.heap().allocate<HTML::HTMLParagraphElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLParagraphElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::param)
-        return *realm.heap().allocate<HTML::HTMLParamElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLParamElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::picture)
-        return *realm.heap().allocate<HTML::HTMLPictureElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLPictureElement>(realm, document, move(qualified_name));
    // NOTE: The obsolete elements "listing" and "xmp" are explicitly mapped to HTMLPreElement in the specification.
    if (lowercase_tag_name.is_one_of(HTML::TagNames::pre, HTML::TagNames::listing, HTML::TagNames::xmp))
-        return *realm.heap().allocate<HTML::HTMLPreElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLPreElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::progress)
-        return *realm.heap().allocate<HTML::HTMLProgressElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLProgressElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(HTML::TagNames::blockquote, HTML::TagNames::q))
-        return *realm.heap().allocate<HTML::HTMLQuoteElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLQuoteElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::script)
-        return *realm.heap().allocate<HTML::HTMLScriptElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLScriptElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::select)
-        return *realm.heap().allocate<HTML::HTMLSelectElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLSelectElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::slot)
-        return *realm.heap().allocate<HTML::HTMLSlotElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLSlotElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::source)
-        return *realm.heap().allocate<HTML::HTMLSourceElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLSourceElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::span)
-        return *realm.heap().allocate<HTML::HTMLSpanElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLSpanElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::style)
-        return *realm.heap().allocate<HTML::HTMLStyleElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLStyleElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::caption)
-        return *realm.heap().allocate<HTML::HTMLTableCaptionElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTableCaptionElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(Web::HTML::TagNames::td, Web::HTML::TagNames::th))
-        return *realm.heap().allocate<HTML::HTMLTableCellElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTableCellElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(HTML::TagNames::colgroup, HTML::TagNames::col))
-        return *realm.heap().allocate<HTML::HTMLTableColElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTableColElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::table)
-        return *realm.heap().allocate<HTML::HTMLTableElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTableElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::tr)
-        return *realm.heap().allocate<HTML::HTMLTableRowElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTableRowElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(HTML::TagNames::tbody, HTML::TagNames::thead, HTML::TagNames::tfoot))
-        return *realm.heap().allocate<HTML::HTMLTableSectionElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTableSectionElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::template_)
-        return *realm.heap().allocate<HTML::HTMLTemplateElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTemplateElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::textarea)
-        return *realm.heap().allocate<HTML::HTMLTextAreaElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTextAreaElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::time)
-        return *realm.heap().allocate<HTML::HTMLTimeElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTimeElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::title)
-        return *realm.heap().allocate<HTML::HTMLTitleElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTitleElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::track)
-        return *realm.heap().allocate<HTML::HTMLTrackElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLTrackElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::ul)
-        return *realm.heap().allocate<HTML::HTMLUListElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLUListElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == HTML::TagNames::video)
-        return *realm.heap().allocate<HTML::HTMLVideoElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLVideoElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.is_one_of(
            HTML::TagNames::article, HTML::TagNames::section, HTML::TagNames::nav, HTML::TagNames::aside, HTML::TagNames::hgroup, HTML::TagNames::header, HTML::TagNames::footer, HTML::TagNames::address, HTML::TagNames::dt, HTML::TagNames::dd, HTML::TagNames::figure, HTML::TagNames::figcaption, HTML::TagNames::main, HTML::TagNames::em, HTML::TagNames::strong, HTML::TagNames::small, HTML::TagNames::s, HTML::TagNames::cite, HTML::TagNames::dfn, HTML::TagNames::abbr, HTML::TagNames::ruby, HTML::TagNames::rt, HTML::TagNames::rp, HTML::TagNames::code, HTML::TagNames::var, HTML::TagNames::samp, HTML::TagNames::kbd, HTML::TagNames::sub, HTML::TagNames::sup, HTML::TagNames::i, HTML::TagNames::b, HTML::TagNames::u, HTML::TagNames::mark, HTML::TagNames::bdi, HTML::TagNames::bdo, HTML::TagNames::wbr, HTML::TagNames::summary, HTML::TagNames::noscript,
            // Obsolete
            HTML::TagNames::acronym, HTML::TagNames::basefont, HTML::TagNames::big, HTML::TagNames::center, HTML::TagNames::nobr, HTML::TagNames::noembed, HTML::TagNames::noframes, HTML::TagNames::plaintext, HTML::TagNames::rb, HTML::TagNames::rtc, HTML::TagNames::strike, HTML::TagNames::tt))
-        return *realm.heap().allocate<HTML::HTMLElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<HTML::HTMLElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::svg)
-        return *realm.heap().allocate<SVG::SVGSVGElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGSVGElement>(realm, document, move(qualified_name));
    // FIXME: Support SVG's mixedCase tag names properly.
    if (lowercase_tag_name.equals_ignoring_case(SVG::TagNames::clipPath))
-        return *realm.heap().allocate<SVG::SVGClipPathElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGClipPathElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::circle)
-        return *realm.heap().allocate<SVG::SVGCircleElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGCircleElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.equals_ignoring_case(SVG::TagNames::defs))
-        return *realm.heap().allocate<SVG::SVGDefsElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGDefsElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::ellipse)
-        return *realm.heap().allocate<SVG::SVGEllipseElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGEllipseElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name.equals_ignoring_case(SVG::TagNames::foreignObject))
-        return *realm.heap().allocate<SVG::SVGForeignObjectElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGForeignObjectElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::line)
-        return *realm.heap().allocate<SVG::SVGLineElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGLineElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::path)
-        return *realm.heap().allocate<SVG::SVGPathElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGPathElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::polygon)
-        return *realm.heap().allocate<SVG::SVGPolygonElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGPolygonElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::polyline)
-        return *realm.heap().allocate<SVG::SVGPolylineElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGPolylineElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::rect)
-        return *realm.heap().allocate<SVG::SVGRectElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGRectElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::g)
-        return *realm.heap().allocate<SVG::SVGGElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGGElement>(realm, document, move(qualified_name));
    if (lowercase_tag_name == SVG::TagNames::text)
-        return *realm.heap().allocate<SVG::SVGTextContentElement>(realm, document, move(qualified_name));
+        return realm.heap().allocate<SVG::SVGTextContentElement>(realm, document, move(qualified_name));

    // FIXME: If name is a valid custom element name, then return HTMLElement.

-    return *realm.heap().allocate<HTML::HTMLUnknownElement>(realm, document, move(qualified_name));
+    return realm.heap().allocate<HTML::HTMLUnknownElement>(realm, document, move(qualified_name));
 }

 }
--- a/Userland/Libraries/LibWeb/DOM/Event.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Event.cpp
@ -16,7 +16,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<Event> Event::create(JS::Realm& realm, FlyString const& event_name, EventInit const& event_init)
 {
-    return *realm.heap().allocate<Event>(realm, realm, event_name, event_init);
+    return realm.heap().allocate<Event>(realm, realm, event_name, event_init);
 }

 JS::NonnullGCPtr<Event> Event::construct_impl(JS::Realm& realm, FlyString const& event_name, EventInit const& event_init)
--- a/Userland/Libraries/LibWeb/DOM/EventTarget.cpp
+++ b/Userland/Libraries/LibWeb/DOM/EventTarget.cpp
@ -128,7 +128,7 @@ void EventTarget::add_event_listener(FlyString const& type, IDLEventListener* ca
    // 2. Add an event listener with this and an event listener whose type is type, callback is callback, capture is capture, passive is passive,
    //    once is once, and signal is signal.

-    auto* event_listener = heap().allocate_without_realm<DOMEventListener>();
+    auto event_listener = heap().allocate_without_realm<DOMEventListener>();
    event_listener->type = type;
    event_listener->callback = callback;
    event_listener->signal = move(flattened_options.signal);
@ -464,7 +464,7 @@ WebIDL::CallbackType* EventTarget::get_current_value_of_event_handler(FlyString
        function->set_script_or_module({});

        // 12. Set eventHandler's value to the result of creating a Web IDL EventHandler callback function object whose object reference is function and whose callback context is settings object.
-        event_handler->value = realm.heap().allocate_without_realm<WebIDL::CallbackType>(*function, settings_object);
+        event_handler->value = realm.heap().allocate_without_realm<WebIDL::CallbackType>(*function, settings_object).ptr();
    }

    // 4. Return eventHandler's value.
@ -498,7 +498,7 @@ void EventTarget::set_event_handler_attribute(FlyString const& name, WebIDL::Cal
    //  3. Set eventHandler's value to the given value.
    if (event_handler_iterator == handler_map.end()) {
        // NOTE: See the optimization comment in get_current_value_of_event_handler about why this is done.
-        auto* new_event_handler = heap().allocate_without_realm<HTML::EventHandler>(*value);
+        auto new_event_handler = heap().allocate_without_realm<HTML::EventHandler>(*value);

        //  4. Activate an event handler given eventTarget and name.
        // Optimization: We pass in the event handler here instead of having activate_event_handler do another hash map lookup just to get the same object.
@ -556,10 +556,10 @@ void EventTarget::activate_event_handler(FlyString const& name, HTML::EventHandl
        0, "", &realm);

    // NOTE: As per the spec, the callback context is arbitrary.
-    auto* callback = realm.heap().allocate_without_realm<WebIDL::CallbackType>(*callback_function, Bindings::host_defined_environment_settings_object(realm));
+    auto callback = realm.heap().allocate_without_realm<WebIDL::CallbackType>(*callback_function, Bindings::host_defined_environment_settings_object(realm));

    // 5. Let listener be a new event listener whose type is the event handler event type corresponding to eventHandler and callback is callback.
-    auto* listener = realm.heap().allocate_without_realm<DOMEventListener>();
+    auto listener = realm.heap().allocate_without_realm<DOMEventListener>();
    listener->type = name;
    listener->callback = IDLEventListener::create(realm, *callback).ptr();

@ -714,7 +714,7 @@ void EventTarget::element_event_handler_attribute_changed(FlyString const& local
    // NOTE: See the optimization comments in set_event_handler_attribute.

    if (event_handler_iterator == handler_map.end()) {
-        auto* new_event_handler = heap().allocate_without_realm<HTML::EventHandler>(value);
+        auto new_event_handler = heap().allocate_without_realm<HTML::EventHandler>(value);

        //  6. Activate an event handler given eventTarget and name.
        event_target->activate_event_handler(local_name, *new_event_handler);
--- a/Userland/Libraries/LibWeb/DOM/HTMLCollection.cpp
+++ b/Userland/Libraries/LibWeb/DOM/HTMLCollection.cpp
@ -15,7 +15,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<HTMLCollection> HTMLCollection::create(ParentNode& root, Function<bool(Element const&)> filter)
 {
-    return *root.heap().allocate<HTMLCollection>(root.realm(), root, move(filter));
+    return root.heap().allocate<HTMLCollection>(root.realm(), root, move(filter));
 }

 HTMLCollection::HTMLCollection(ParentNode& root, Function<bool(Element const&)> filter)
--- a/Userland/Libraries/LibWeb/DOM/IDLEventListener.cpp
+++ b/Userland/Libraries/LibWeb/DOM/IDLEventListener.cpp
@ -10,7 +10,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<IDLEventListener> IDLEventListener::create(JS::Realm& realm, JS::NonnullGCPtr<WebIDL::CallbackType> callback)
 {
-    return *realm.heap().allocate<IDLEventListener>(realm, realm, move(callback));
+    return realm.heap().allocate<IDLEventListener>(realm, realm, move(callback));
 }

 IDLEventListener::IDLEventListener(JS::Realm& realm, JS::NonnullGCPtr<WebIDL::CallbackType> callback)
--- a/Userland/Libraries/LibWeb/DOM/LiveNodeList.cpp
+++ b/Userland/Libraries/LibWeb/DOM/LiveNodeList.cpp
@ -12,7 +12,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<NodeList> LiveNodeList::create(JS::Realm& realm, Node& root, Function<bool(Node const&)> filter)
 {
-    return *realm.heap().allocate<LiveNodeList>(realm, realm, root, move(filter));
+    return realm.heap().allocate<LiveNodeList>(realm, realm, root, move(filter));
 }

 LiveNodeList::LiveNodeList(JS::Realm& realm, Node& root, Function<bool(Node const&)> filter)
--- a/Userland/Libraries/LibWeb/DOM/MutationObserver.cpp
+++ b/Userland/Libraries/LibWeb/DOM/MutationObserver.cpp
@ -13,7 +13,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<MutationObserver> MutationObserver::construct_impl(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback)
 {
-    return *realm.heap().allocate<MutationObserver>(realm, realm, callback);
+    return realm.heap().allocate<MutationObserver>(realm, realm, callback);
 }

 // https://dom.spec.whatwg.org/#dom-mutationobserver-mutationobserver
@ -142,7 +142,7 @@ Vector<JS::Handle<MutationRecord>> MutationObserver::take_records()

 JS::NonnullGCPtr<RegisteredObserver> RegisteredObserver::create(MutationObserver& observer, MutationObserverInit const& options)
 {
-    return *observer.heap().allocate_without_realm<RegisteredObserver>(observer, options);
+    return observer.heap().allocate_without_realm<RegisteredObserver>(observer, options);
 }

 RegisteredObserver::RegisteredObserver(MutationObserver& observer, MutationObserverInit const& options)
@ -161,7 +161,7 @@ void RegisteredObserver::visit_edges(Cell::Visitor& visitor)

 JS::NonnullGCPtr<TransientRegisteredObserver> TransientRegisteredObserver::create(MutationObserver& observer, MutationObserverInit const& options, RegisteredObserver& source)
 {
-    return *observer.heap().allocate_without_realm<TransientRegisteredObserver>(observer, options, source);
+    return observer.heap().allocate_without_realm<TransientRegisteredObserver>(observer, options, source);
 }

 TransientRegisteredObserver::TransientRegisteredObserver(MutationObserver& observer, MutationObserverInit const& options, RegisteredObserver& source)
--- a/Userland/Libraries/LibWeb/DOM/MutationRecord.cpp
+++ b/Userland/Libraries/LibWeb/DOM/MutationRecord.cpp
@ -14,7 +14,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<MutationRecord> MutationRecord::create(JS::Realm& realm, FlyString const& type, Node& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, DeprecatedString const& attribute_name, DeprecatedString const& attribute_namespace, DeprecatedString const& old_value)
 {
-    return *realm.heap().allocate<MutationRecord>(realm, realm, type, target, added_nodes, removed_nodes, previous_sibling, next_sibling, attribute_name, attribute_namespace, old_value);
+    return realm.heap().allocate<MutationRecord>(realm, realm, type, target, added_nodes, removed_nodes, previous_sibling, next_sibling, attribute_name, attribute_namespace, old_value);
 }

 MutationRecord::MutationRecord(JS::Realm& realm, FlyString const& type, Node& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, DeprecatedString const& attribute_name, DeprecatedString const& attribute_namespace, DeprecatedString const& old_value)
--- a/Userland/Libraries/LibWeb/DOM/NamedNodeMap.cpp
+++ b/Userland/Libraries/LibWeb/DOM/NamedNodeMap.cpp
@ -15,7 +15,7 @@ namespace Web::DOM {
 JS::NonnullGCPtr<NamedNodeMap> NamedNodeMap::create(Element& element)
 {
    auto& realm = element.realm();
-    return *realm.heap().allocate<NamedNodeMap>(realm, element);
+    return realm.heap().allocate<NamedNodeMap>(realm, element);
 }

 NamedNodeMap::NamedNodeMap(Element& element)
--- a/Userland/Libraries/LibWeb/DOM/NodeFilter.cpp
+++ b/Userland/Libraries/LibWeb/DOM/NodeFilter.cpp
@ -11,7 +11,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<NodeFilter> NodeFilter::create(JS::Realm& realm, WebIDL::CallbackType& callback)
 {
-    return *realm.heap().allocate<NodeFilter>(realm, realm, callback);
+    return realm.heap().allocate<NodeFilter>(realm, realm, callback);
 }

 NodeFilter::NodeFilter(JS::Realm& realm, WebIDL::CallbackType& callback)
--- a/Userland/Libraries/LibWeb/DOM/NodeIterator.cpp
+++ b/Userland/Libraries/LibWeb/DOM/NodeIterator.cpp
@ -45,7 +45,7 @@ JS::NonnullGCPtr<NodeIterator> NodeIterator::create(Node& root, unsigned what_to
    // 2. Set iterator’s root and iterator’s reference to root.
    // 3. Set iterator’s pointer before reference to true.
    auto& realm = root.realm();
-    auto* iterator = realm.heap().allocate<NodeIterator>(realm, root);
+    auto iterator = realm.heap().allocate<NodeIterator>(realm, root);

    // 4. Set iterator’s whatToShow to whatToShow.
    iterator->m_what_to_show = what_to_show;
@ -54,7 +54,7 @@ JS::NonnullGCPtr<NodeIterator> NodeIterator::create(Node& root, unsigned what_to
    iterator->m_filter = filter;

    // 6. Return iterator.
-    return *iterator;
+    return iterator;
 }

 // https://dom.spec.whatwg.org/#dom-nodeiterator-detach
--- a/Userland/Libraries/LibWeb/DOM/NodeOperations.cpp
+++ b/Userland/Libraries/LibWeb/DOM/NodeOperations.cpp
@ -26,14 +26,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> convert_nodes_to_single_node(Vector<
        if (node.has<JS::Handle<Node>>())
            return *node.get<JS::Handle<Node>>();

-        return *document.heap().allocate<DOM::Text>(document.realm(), document, node.get<DeprecatedString>());
+        return document.heap().allocate<DOM::Text>(document.realm(), document, node.get<DeprecatedString>());
    };

    if (nodes.size() == 1)
        return potentially_convert_string_to_text_node(nodes.first());

-    // This is NNGCP<Node> instead of NNGCP<DocumentFragment> to be compatible with the return type.
-    JS::NonnullGCPtr<Node> document_fragment = *document.heap().allocate<DOM::DocumentFragment>(document.realm(), document);
+    auto document_fragment = document.heap().allocate<DOM::DocumentFragment>(document.realm(), document);
    for (auto& unconverted_node : nodes) {
        auto node = potentially_convert_string_to_text_node(unconverted_node);
        (void)TRY(document_fragment->append_child(node));
--- a/Userland/Libraries/LibWeb/DOM/Range.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Range.cpp
@ -34,13 +34,13 @@ JS::NonnullGCPtr<Range> Range::create(HTML::Window& window)
 JS::NonnullGCPtr<Range> Range::create(Document& document)
 {
    auto& realm = document.realm();
-    return *realm.heap().allocate<Range>(realm, document);
+    return realm.heap().allocate<Range>(realm, document);
 }

 JS::NonnullGCPtr<Range> Range::create(Node& start_container, u32 start_offset, Node& end_container, u32 end_offset)
 {
    auto& realm = start_container.realm();
-    return *realm.heap().allocate<Range>(realm, start_container, start_offset, end_container, end_offset);
+    return realm.heap().allocate<Range>(realm, start_container, start_offset, end_container, end_offset);
 }

 JS::NonnullGCPtr<Range> Range::construct_impl(JS::Realm& realm)
@ -396,12 +396,12 @@ WebIDL::ExceptionOr<void> Range::select_node_contents(Node const& node)

 JS::NonnullGCPtr<Range> Range::clone_range() const
 {
-    return *heap().allocate<Range>(shape().realm(), const_cast<Node&>(*m_start_container), m_start_offset, const_cast<Node&>(*m_end_container), m_end_offset);
+    return heap().allocate<Range>(shape().realm(), const_cast<Node&>(*m_start_container), m_start_offset, const_cast<Node&>(*m_end_container), m_end_offset);
 }

 JS::NonnullGCPtr<Range> Range::inverted() const
 {
-    return *heap().allocate<Range>(shape().realm(), const_cast<Node&>(*m_end_container), m_end_offset, const_cast<Node&>(*m_start_container), m_start_offset);
+    return heap().allocate<Range>(shape().realm(), const_cast<Node&>(*m_end_container), m_end_offset, const_cast<Node&>(*m_start_container), m_start_offset);
 }

 JS::NonnullGCPtr<Range> Range::normalized() const
@ -555,11 +555,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract_contents(
 WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
 {
    // 1. Let fragment be a new DocumentFragment node whose node document is range’s start node’s node document.
-    auto* fragment = heap().allocate<DOM::DocumentFragment>(realm(), const_cast<Document&>(start_container()->document()));
+    auto fragment = heap().allocate<DOM::DocumentFragment>(realm(), const_cast<Document&>(start_container()->document()));

    // 2. If range is collapsed, then return fragment.
    if (collapsed())
-        return JS::NonnullGCPtr(*fragment);
+        return fragment;

    // 3. Let original start node, original start offset, original end node, and original end offset
    //    be range’s start node, start offset, end node, and end offset, respectively.
@ -585,7 +585,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
        TRY(static_cast<CharacterData&>(*original_start_node).replace_data(original_start_offset, original_end_offset - original_start_offset, ""));

        // 5. Return fragment.
-        return JS::NonnullGCPtr(*fragment);
+        return fragment;
    }

    // 5. Let common ancestor be original start node.
@ -735,7 +735,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
    TRY(set_end(*new_node, new_offset));

    // 21. Return fragment.
-    return JS::NonnullGCPtr(*fragment);
+    return fragment;
 }

 // https://dom.spec.whatwg.org/#contained
@ -884,11 +884,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_contents()
 WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_contents()
 {
    // 1. Let fragment be a new DocumentFragment node whose node document is range’s start node’s node document.
-    auto* fragment = heap().allocate<DOM::DocumentFragment>(realm(), const_cast<Document&>(start_container()->document()));
+    auto fragment = heap().allocate<DOM::DocumentFragment>(realm(), const_cast<Document&>(start_container()->document()));

    // 2. If range is collapsed, then return fragment.
    if (collapsed())
-        return JS::NonnullGCPtr(*fragment);
+        return fragment;

    // 3. Let original start node, original start offset, original end node, and original end offset
    //    be range’s start node, start offset, end node, and end offset, respectively.
@ -911,7 +911,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_content
        TRY(fragment->append_child(clone));

        // 4. Return fragment.
-        return JS::NonnullGCPtr(*fragment);
+        return fragment;
    }

    // 5. Let common ancestor be original start node.
@ -1033,7 +1033,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_content
    }

    // 18. Return fragment.
-    return JS::NonnullGCPtr(*fragment);
+    return fragment;
 }

 // https://dom.spec.whatwg.org/#dom-range-deletecontents
--- a/Userland/Libraries/LibWeb/DOM/StaticNodeList.cpp
+++ b/Userland/Libraries/LibWeb/DOM/StaticNodeList.cpp
@ -11,7 +11,7 @@ namespace Web::DOM {

 JS::NonnullGCPtr<NodeList> StaticNodeList::create(JS::Realm& realm, Vector<JS::Handle<Node>> static_nodes)
 {
-    return *realm.heap().allocate<StaticNodeList>(realm, realm, move(static_nodes));
+    return realm.heap().allocate<StaticNodeList>(realm, realm, move(static_nodes));
 }

 StaticNodeList::StaticNodeList(JS::Realm& realm, Vector<JS::Handle<Node>> static_nodes)
--- a/Userland/Libraries/LibWeb/DOM/StaticRange.cpp
+++ b/Userland/Libraries/LibWeb/DOM/StaticRange.cpp
@ -33,7 +33,7 @@ WebIDL::ExceptionOr<StaticRange*> StaticRange::construct_impl(JS::Realm& realm,
        return WebIDL::InvalidNodeTypeError::create(realm, "endContainer cannot be a DocumentType or Attribute node.");

    // 2. Set this’s start to (init["startContainer"], init["startOffset"]) and end to (init["endContainer"], init["endOffset"]).
-    return realm.heap().allocate<StaticRange>(realm, *init.start_container, init.start_offset, *init.end_container, init.end_offset);
+    return realm.heap().allocate<StaticRange>(realm, *init.start_container, init.start_offset, *init.end_container, init.end_offset).ptr();
 }

 }
--- a/Userland/Libraries/LibWeb/DOM/Text.cpp
+++ b/Userland/Libraries/LibWeb/DOM/Text.cpp
@ -37,7 +37,7 @@ JS::NonnullGCPtr<Text> Text::construct_impl(JS::Realm& realm, DeprecatedString c
 {
    // The new Text(data) constructor steps are to set this’s data to data and this’s node document to current global object’s associated Document.
    auto& window = verify_cast<HTML::Window>(HTML::current_global_object());
-    return *realm.heap().allocate<Text>(realm, window.associated_document(), data);
+    return realm.heap().allocate<Text>(realm, window.associated_document(), data);
 }

 void Text::set_owner_input_element(Badge<HTML::HTMLInputElement>, HTML::HTMLInputElement& input_element)
@ -63,7 +63,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> Text::split_text(size_t offset)
    auto new_data = TRY(substring_data(offset, count));

    // 5. Let new node be a new Text node, with the same node document as node. Set new node’s data to new data.
-    auto new_node = JS::NonnullGCPtr(*heap().allocate<Text>(realm(), document(), new_data));
+    auto new_node = heap().allocate<Text>(realm(), document(), new_data);

    // 6. Let parent be node’s parent.
    JS::GCPtr<Node> parent = this->parent();
--- a/Userland/Libraries/LibWeb/DOM/TreeWalker.cpp
+++ b/Userland/Libraries/LibWeb/DOM/TreeWalker.cpp
@ -36,7 +36,7 @@ JS::NonnullGCPtr<TreeWalker> TreeWalker::create(Node& root, unsigned what_to_sho
    // 1. Let walker be a new TreeWalker object.
    // 2. Set walker’s root and walker’s current to root.
    auto& realm = root.realm();
-    auto* walker = realm.heap().allocate<TreeWalker>(realm, root);
+    auto walker = realm.heap().allocate<TreeWalker>(realm, root);

    // 3. Set walker’s whatToShow to whatToShow.
    walker->m_what_to_show = what_to_show;
@ -45,7 +45,7 @@ JS::NonnullGCPtr<TreeWalker> TreeWalker::create(Node& root, unsigned what_to_sho
    walker->m_filter = filter;

    // 5. Return walker.
-    return *walker;
+    return walker;
 }

 // https://dom.spec.whatwg.org/#dom-treewalker-currentnode