ladybird/Userland/Libraries/LibWeb/DOM/Utils.h
Daniel Bertalan 31eb0ed938 LibWeb/DOM: Work around GCC 14 warning on always true is<T>()
GCC 14 emits a warning when an always succeeding `dynamic_cast`'s return
value is compared to NULL inside the `AK::is<T>(U)` template when `T` ==
`U`.

While warning on tautological `is` calls seems useful, it's a bit
awkward when it comes from a function template where the cast may fail
in some instantiation. There is a GCC bug open for it:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115664

Work around the warning by performing the algorithm on the base type
(`EventTarget`), with a wrapper that casts it to the more specialized
input type.
2024-07-19 09:18:27 +02:00

48 lines
1.3 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (c) 2020, Luke Wilde <lukew@serenityos.org>
* Copyright (c) 2024, circl <circl.lastname@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibWeb/DOM/Node.h>
#include <LibWeb/DOM/ShadowRoot.h>
namespace Web::DOM {
// https://dom.spec.whatwg.org/#retarget
inline EventTarget* retarget_impl(EventTarget* a, EventTarget* b)
{
// To retarget an object A against an object B, repeat these steps until they return an object:
for (;;) {
// 1. If one of the following is true then return A.
// - A is not a node
if (!is<Node>(a))
return a;
// - As root is not a shadow root
auto* a_node = verify_cast<Node>(a);
auto& a_root = a_node->root();
if (!is<ShadowRoot>(a_root))
return a;
// - B is a node and As root is a shadow-including inclusive ancestor of B
if (is<Node>(b) && a_root.is_shadow_including_inclusive_ancestor_of(verify_cast<Node>(*b)))
return a;
// 2. Set A to As roots host.
auto& a_shadow_root = verify_cast<ShadowRoot>(a_root);
a = a_shadow_root.host();
}
}
// https://dom.spec.whatwg.org/#retarget
template<typename T>
T* retarget(T* a, T* b)
{
return static_cast<T*>(retarget_impl(a, b));
}
}