blob: 52f93a550d3a752d625f8ac7f6004dc1d84fb57f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/*
* Copyright (c) 2021, the SerenityOS developers.
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Optional.h>
#include <AK/StdLibExtras.h>
#include <LibJS/Runtime/VM.h>
#include <LibWeb/Bindings/DOMExceptionWrapper.h>
#include <LibWeb/DOM/ExceptionOr.h>
namespace Web::Bindings {
template<typename>
constexpr bool IsExceptionOr = false;
template<typename T>
constexpr bool IsExceptionOr<DOM::ExceptionOr<T>> = true;
template<typename>
constexpr bool IsThrowCompletionOr = false;
template<typename T>
constexpr bool IsThrowCompletionOr<JS::ThrowCompletionOr<T>> = true;
namespace Detail {
template<typename T>
struct ExtractExceptionOrValueType {
using Type = T;
};
template<typename T>
struct ExtractExceptionOrValueType<DOM::ExceptionOr<T>> {
using Type = T;
};
template<typename T>
struct ExtractExceptionOrValueType<JS::ThrowCompletionOr<T>> {
using Type = T;
};
template<>
struct ExtractExceptionOrValueType<void> {
using Type = JS::Value;
};
template<>
struct ExtractExceptionOrValueType<DOM::ExceptionOr<Empty>> {
using Type = JS::Value;
};
template<>
struct ExtractExceptionOrValueType<DOM::ExceptionOr<void>> {
using Type = JS::Value;
};
ALWAYS_INLINE JS::Completion dom_exception_to_throw_completion(auto&& vm, auto&& exception)
{
return exception.visit(
[&](DOM::SimpleException const& exception) {
switch (exception.type) {
#define E(x) \
case DOM::SimpleExceptionType::x: \
return vm.template throw_completion<JS::x>(exception.message);
ENUMERATE_SIMPLE_WEBIDL_EXCEPTION_TYPES(E)
#undef E
default:
VERIFY_NOT_REACHED();
}
},
[&](NonnullRefPtr<DOM::DOMException> exception) {
return vm.template throw_completion<DOMExceptionWrapper>(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>: 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> && !IsThrowCompletionOr<T>, T, ExtractExceptionOrValueType<T>>>
JS::ThrowCompletionOr<Ret> throw_dom_exception_if_needed(auto&& vm, F&& fn)
{
if constexpr (IsExceptionOr<T>) {
auto&& result = fn();
if (result.is_exception())
return Detail::dom_exception_to_throw_completion(vm, result.exception());
if constexpr (requires(T v) { v.value(); })
return result.value();
else
return JS::js_undefined();
} else if constexpr (IsVoid<T>) {
fn();
return JS::js_undefined();
} else {
return fn();
}
}
}
|
