RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-06-01 07:48:12 +00:00
Code Issues Activity Actions

LibWeb: Make ExceptionOr capable of holding all error types in the spec

Browse source 
The WebIDL spec specifies a few "simple" exception types in addition to
the DOMException type, let's support all of those.
This allows functions returning ExceptionOr<T> to throw regular
javascript exceptions (as limited by the webidl spec) by returning a
`DOM::SimpleException { DOM::SimpleExceptionType::T, "error message" }`
which is pretty damn cool :^)
This commit is contained in:
Ali Mohammad Pur 2021-06-27 00:17:13 +04:30 • committed by Linus Groh
parent bda19a9ff3
commit fd72597999
4 changed files with 77 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

96
Userland/Libraries/LibWeb/DOM/ExceptionOr.h
View file

@ -13,9 +13,29 @@
namespace Web::DOM {
#define ENUMERATE_SIMPLE_WEBIDL_EXCEPTION_TYPES(E) \
E(EvalError) \
E(RangeError) \
E(ReferenceError) \
E(TypeError) \
E(URIError)
#define E(x) x,
enum class SimpleExceptionType {
ENUMERATE_SIMPLE_WEBIDL_EXCEPTION_TYPES(E)
};
#undef E
struct SimpleException {
SimpleExceptionType type;
String message;
};
template<typename ValueType>
class ExceptionOr {
public:
ExceptionOr() requires(IsSame<ValueType, Empty>) = default;
ExceptionOr(const ValueType& result)
: m_result(result)
{
@ -26,8 +46,18 @@ public:
{
}
ExceptionOr(const NonnullRefPtr<DOMException> exception)
: m_exception(exception)
ExceptionOr(NonnullRefPtr<DOMException> exception)
: m_exception(move(exception))
{
}
ExceptionOr(SimpleException exception)
: m_exception(move(exception))
{
}
ExceptionOr(Variant<SimpleException, NonnullRefPtr<DOMException>> exception)
: m_exception(move(exception).template downcast<Empty, SimpleException, NonnullRefPtr<DOMException>>())
{
}
@ -35,56 +65,60 @@ public:
ExceptionOr(const ExceptionOr& other) = default;
~ExceptionOr() = default;
ValueType& value()
ValueType& value() requires(!IsSame<ValueType, Empty>)
{
return m_result.value();
}
ValueType release_value()
ValueType release_value() requires(!IsSame<ValueType, Empty>)
{
return m_result.release_value();
}
const DOMException& exception() const
Variant<SimpleException, NonnullRefPtr<DOMException>> exception() const
{
return *m_exception;
return m_exception.template downcast<SimpleException, NonnullRefPtr<DOMException>>();
}
auto materialized_exception(JS::GlobalObject& global_object) const
{
#define E(x) JS::x*,
using ResultType = Variant<ENUMERATE_SIMPLE_WEBIDL_EXCEPTION_TYPES(E) NonnullRefPtr<DOMException>>;
#undef E
return m_exception.visit(
[&](SimpleException& exception) -> ResultType {
switch (exception.type) {
#define E(x) \
case SimpleExceptionType::x: \
return JS::x::create(global_object, exception.message);
ENUMERATE_SIMPLE_WEBIDL_EXCEPTION_TYPES(E)
#undef E
default:
VERIFY_NOT_REACHED();
}
},
[&](NonnullRefPtr<DOMException> const& exception) -> ResultType { return exception; },
[](Empty) -> ResultType { VERIFY_NOT_REACHED(); });
}
bool is_exception() const
{
return m_exception;
return !m_exception.template has<Empty>();
}
private:
Optional<ValueType> m_result;
RefPtr<DOMException> m_exception;
// https://heycam.github.io/webidl/#idl-exceptions
Variant<Empty, SimpleException, NonnullRefPtr<DOMException>> m_exception { Empty {} };
};
template<>
class ExceptionOr<void> {
class ExceptionOr<void> : public ExceptionOr<Empty> {
public:
ExceptionOr(const NonnullRefPtr<DOMException> exception)
: m_exception(exception)
{
}
ExceptionOr() = default;
ExceptionOr(ExceptionOr&& other) = default;
ExceptionOr(const ExceptionOr& other) = default;
~ExceptionOr() = default;
const DOMException& exception() const
{
return *m_exception;
}
bool is_exception() const
{
return m_exception;
}
private:
RefPtr<DOMException> m_exception;
using ExceptionOr<Empty>::ExceptionOr;
};
}