RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 05:37:44 +00:00
Code Issues Activity Actions

LibWeb: Convert throw_dom_exception_if_needed() to ThrowCompletionOr

Browse source 
This changes Web::Bindings::throw_dom_exception_if_needed() to return a
JS::ThrowCompletionOr instead of an Optional. This allows callers to
wrap the invocation with a TRY() macro instead of making a follow-up
call to should_return_empty(). Further, this removes all invocations to
vm.exception() in the generated bindings.
This commit is contained in:
Timothy Flynn 2021-10-31 13:07:52 -04:00 • committed by Linus Groh
parent e3b7c305bc
commit 95e492de59
4 changed files with 84 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

58
Userland/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
View file

@ -20,19 +20,6 @@ constexpr bool IsExceptionOr = false;
template<typename T>
constexpr bool IsExceptionOr<DOM::ExceptionOr<T>> = true;
template<typename T>
ALWAYS_INLINE bool throw_dom_exception(JS::VM& vm, JS::GlobalObject& global_object, DOM::ExceptionOr<T>& result)
{
if (result.is_exception()) {
result.materialized_exception(global_object)
.visit(
[&](NonnullRefPtr<DOM::DOMException> dom_exception) { vm.throw_exception(global_object, DOMExceptionWrapper::create(global_object, move(dom_exception))); },
[&](auto* js_exception) { vm.throw_exception(global_object, js_exception); });
return true;
}
return false;
}
namespace Detail {
template<typename T>
@ -60,22 +47,47 @@ struct ExtractExceptionOrValueType<DOM::ExceptionOr<void>> {
using Type = JS::Value;
};
ALWAYS_INLINE JS::Completion dom_exception_to_throw_completion(auto&& global_object, auto&& exception)
{
auto& vm = global_object.vm();
return exception.visit(
[&](DOM::SimpleException const& exception) {
switch (exception.type) {
#define E(x) \
case DOM::SimpleExceptionType::x: \
return vm.template throw_completion<JS::x>(global_object, exception.message);
ENUMERATE_SIMPLE_WEBIDL_EXCEPTION_TYPES(E)
#undef E
default:
VERIFY_NOT_REACHED();
}
},
[&](NonnullRefPtr<DOM::DOMException> exception) {
return vm.template throw_completion<DOMExceptionWrapper>(global_object, move(exception));
});
}
}
template<typename T>
using ExtractExceptionOrValueType = typename Detail::ExtractExceptionOrValueType<T>::Type;
// Return type depends on the return type of 'fn' (when invoked with no args):
// void or ExceptionOr<void>: Optional<JS::Value>, always returns JS::js_undefined()
// ExceptionOr<T>: Optional<T>
// T: Optional<T>
// void or ExceptionOr<void>: JS::ThrowCompletionOr<JS::Value>, always returns JS::js_undefined()
// ExceptionOr<T>: JS::ThrowCompletionOr<T>
// T: JS::ThrowCompletionOr<T>
template<typename F, typename T = decltype(declval<F>()()), typename Ret = Conditional<!IsExceptionOr<T> && !IsVoid<T>, T, ExtractExceptionOrValueType<T>>>
Optional<Ret> throw_dom_exception_if_needed(auto&& vm, auto&& global_object, F&& fn)
JS::ThrowCompletionOr<Ret> throw_dom_exception_if_needed(auto&& global_object, F&& fn)
{
if constexpr (IsExceptionOr<T>) {
auto&& result = fn();
if (throw_dom_exception(vm, global_object, result))
return {};
if (result.is_exception())
return Detail::dom_exception_to_throw_completion(global_object, result.exception());
if constexpr (requires(T v) { v.value(); })
return result.value();
else
@ -88,12 +100,4 @@ Optional<Ret> throw_dom_exception_if_needed(auto&& vm, auto&& global_object, F&&
}
}
template<typename T>
bool should_return_empty(const Optional<T>& value)
{
if constexpr (IsSame<JS::Value, T>)
return !value.has_value() || value.value().is_empty();
return !value.has_value();
}
}