beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-21 23:20:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/AK/Error.h

179 lines
4.9 KiB
C
Raw Normal View History

AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/StringView.h>
AK: Make Error.h pull in Try.h Users of this API will want TRY().
2021-11-07 23:35:58 +00:00
#include <AK/Try.h>
AK+Tests: Use less space in ErrorOr
2021-12-14 22:02:23 +00:00
#include <AK/Variant.h>
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
Everywhere: Replace uses of __serenity__ with AK_OS_SERENITY Now that we have OS macros for essentially every supported OS, let's try to use them everywhere.
2022-10-09 21:23:23 +00:00
#if defined(AK_OS_SERENITY) && defined(KERNEL)
Everywhere: Remove "LibC/" includes, add lint-rule against it
2023-01-03 14:30:44 +00:00
# include <errno_codes.h>
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
#else
# include <errno.h>
AK+LibMain: Improve formatter for AK::Error in userspace Print the full associated string metadata by default (if available.)
2021-12-20 10:55:32 +00:00
# include <string.h>
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
#endif
namespace AK {
class Error {
public:
AK: Disallow implicitly copying Error and ErrorOr instances In the rare cases that a copy is actually needed, the Error::copy factory will suffice.
2023-02-09 18:47:28 +00:00
ALWAYS_INLINE Error(Error&&) = default;
ALWAYS_INLINE Error& operator=(Error&&) = default;
AK: Mark Error::from_ functions as [[nodiscard]] Prevents mistakes like the one fixed in #16672.
2022-12-26 14:17:22 +00:00
[[nodiscard]] static Error from_errno(int code) { return Error(code); }
AK: Add a new method to propagate errno while printing errors in Kernel This new method is meant to be used in both userspace and kernel code. The idea is to allow printing of a verbose message and then returning an errno code which is the proper mechanism for kernel code because we should almost always assume that such error will be propagated back to userspace in some way, so the userspace code could reasonably decode it. For userspace code however, this new method is meant to be a simple wrapper for Error::from_string_view, because for most invocations, it's much more useful to have a verbose & literal error than a errno code, so we simply ignore that errno code completely in such context.
2023-02-05 10:27:38 +00:00
// NOTE: For calling this method from within kernel code, we will simply print
// the error message and return the errno code.
// For calling this method from userspace programs, we will simply return from
// the Error::from_string_view method!
[[nodiscard]] static Error from_string_view_or_print_error_and_return_errno(StringView string_literal, int code);
AK: Mark Error::from_ functions as [[nodiscard]] Prevents mistakes like the one fixed in #16672.
2022-12-26 14:17:22 +00:00
[[nodiscard]] static Error from_syscall(StringView syscall_name, int rc) { return Error(syscall_name, rc); }
[[nodiscard]] static Error from_string_view(StringView string_literal) { return Error(string_literal); }
Everywhere: Split Error::from_string_literal and Error::from_string_view Error::from_string_literal now takes direct char const*s, while Error::from_string_view does what Error::from_string_literal used to do: taking StringViews. This change will remove the need to insert `sv` after error strings when returning string literal errors once StringView(char const*) is removed. No functional changes.
2022-07-11 17:57:32 +00:00
AK: Add an explicit Error factory to copy an existing error As of now, there is a default copy constructor on Error. A future commit will make this non-public to prevent implicit copies, so to prepare for that, this adds a factory for the few cases where a copy is really needed.
2023-02-09 19:15:58 +00:00
[[nodiscard]] static Error copy(Error const& error)
{
return Error(error);
}
Everywhere: Split Error::from_string_literal and Error::from_string_view Error::from_string_literal now takes direct char const*s, while Error::from_string_view does what Error::from_string_literal used to do: taking StringViews. This change will remove the need to insert `sv` after error strings when returning string literal errors once StringView(char const*) is removed. No functional changes.
2022-07-11 17:57:32 +00:00
// NOTE: Prefer `from_string_literal` when directly typing out an error message:
//
// return Error::from_string_literal("Class: Some failure");
//
// If you need to return a static string based on a dynamic condition (like
// picking an error from an array), then prefer `from_string_view` instead.
template<size_t N>
AK: Mark Error::from_ functions as [[nodiscard]] Prevents mistakes like the one fixed in #16672.
2022-12-26 14:17:22 +00:00
[[nodiscard]] ALWAYS_INLINE static Error from_string_literal(char const (&string_literal)[N])
Everywhere: Split Error::from_string_literal and Error::from_string_view Error::from_string_literal now takes direct char const*s, while Error::from_string_view does what Error::from_string_literal used to do: taking StringViews. This change will remove the need to insert `sv` after error strings when returning string literal errors once StringView(char const*) is removed. No functional changes.
2022-07-11 17:57:32 +00:00
{
return from_string_view(StringView { string_literal, N - 1 });
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: Add a Error::__jakt_from_string_literal(StringView) factory function Note that Jakt only allows StringView creation from string literals, so none of the invariants in the class are broken by this (if used only from within Jakt).
2022-12-10 15:59:22 +00:00
// Note: Don't call this from C++; it's here for Jakt interop (as the name suggests).
template<SameAs<StringView> T>
ALWAYS_INLINE static Error __jakt_from_string_literal(T string)
{
return from_string_view(string);
}
AK: Add Error::operator==(Error const&)
2022-06-08 13:56:21 +00:00
bool operator==(Error const& other) const
{
return m_code == other.m_code && m_string_literal == other.m_string_literal && m_syscall == other.m_syscall;
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
bool is_errno() const { return m_code != 0; }
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
bool is_syscall() const { return m_syscall; }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
int code() const { return m_code; }
StringView string_literal() const { return m_string_literal; }
AK: Allow subclassing Error
2021-11-07 00:30:35 +00:00
protected:
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
Error(int code)
: m_code(code)
{
}
AK: Allow subclassing Error
2021-11-07 00:30:35 +00:00
private:
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
Error(StringView string_literal)
: m_string_literal(string_literal)
{
}
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
Error(StringView syscall_name, int rc)
AK: Rearrange Error's members to reduce its size by 8 bytes This shrinks sizeof(Error) from 32 bytes to 24 bytes, which in turn will shrink sizeof(ErrorOr<T>) by the same amount (in cases where sizeof(T) is less than sizeof(Error)).
2022-12-22 13:56:32 +00:00
: m_string_literal(syscall_name)
, m_code(-rc)
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
, m_syscall(true)
{
}
AK: Disallow implicitly copying Error and ErrorOr instances In the rare cases that a copy is actually needed, the Error::copy factory will suffice.
2023-02-09 18:47:28 +00:00
Error(Error const&) = default;
Error& operator=(Error const&) = default;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
StringView m_string_literal;
AK: Rearrange Error's members to reduce its size by 8 bytes This shrinks sizeof(Error) from 32 bytes to 24 bytes, which in turn will shrink sizeof(ErrorOr<T>) by the same amount (in cases where sizeof(T) is less than sizeof(Error)).
2022-12-22 13:56:32 +00:00
int m_code { 0 };
AK+LibSystem+LibMain: Add Error::from_syscall() for syscall failures This creates an error that contains the name of the syscall that failed. This allows error handlers to print out the name of the call if they want to. :^)
2021-11-22 15:00:53 +00:00
bool m_syscall { false };
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
};
AK: Let ErrorOr<T, E> expose its result/error types `ErrorOr<T, E>::ResultType` can now refer to `T`.
2022-12-10 11:59:20 +00:00
template<typename T, typename E>
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
class [[nodiscard]] ErrorOr {
AK: Fix constructing ErrorOr from ErrorOr of a related type Mark other ErrorOr types as friends, and fix a typo in the && constructor, so that we can create an ErrorOr<Core::Object> from an ErrorOr<GUI::Widget>. Also, add some requires() clauses to these constructors so the error messages are clearer.
2022-12-28 20:12:03 +00:00
template<typename U, typename F>
friend class ErrorOr;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
public:
AK: Let ErrorOr<T, E> expose its result/error types `ErrorOr<T, E>::ResultType` can now refer to `T`.
2022-12-10 11:59:20 +00:00
using ResultType = T;
using ErrorType = E;
Everywhere: Run clang-format
2022-10-16 22:06:11 +00:00
ErrorOr()
requires(IsSame<T, Empty>)
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
: m_value_or_error(Empty {})
{
}
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: Elaborate the Error constructors a bit The old constraints were making clang mad, so express them in a less complex way.
2022-12-09 16:38:09 +00:00
ALWAYS_INLINE ErrorOr(ErrorOr&&) = default;
ALWAYS_INLINE ErrorOr& operator=(ErrorOr&&) = default;
AK: Disallow implicitly copying Error and ErrorOr instances In the rare cases that a copy is actually needed, the Error::copy factory will suffice.
2023-02-09 18:47:28 +00:00
ErrorOr(ErrorOr const&) = delete;
ErrorOr& operator=(ErrorOr const&) = delete;
AK: Elaborate the Error constructors a bit The old constraints were making clang mad, so express them in a less complex way.
2022-12-09 16:38:09 +00:00
template<typename U>
ALWAYS_INLINE ErrorOr(ErrorOr<U, ErrorType>&& value)
AK: Fix constructing ErrorOr from ErrorOr of a related type Mark other ErrorOr types as friends, and fix a typo in the && constructor, so that we can create an ErrorOr<Core::Object> from an ErrorOr<GUI::Widget>. Also, add some requires() clauses to these constructors so the error messages are clearer.
2022-12-28 20:12:03 +00:00
requires(IsConvertible<U, T>)
: m_value_or_error(value.m_value_or_error.visit([](U& v) { return Variant<T, ErrorType>(move(v)); }, [](ErrorType& error) { return Variant<T, ErrorType>(move(error)); }))
AK: Elaborate the Error constructors a bit The old constraints were making clang mad, so express them in a less complex way.
2022-12-09 16:38:09 +00:00
{
}
AK: Add some more ways to construct Error and ErrorOr<T> This is preparation for using Error in the kernel instead of KResult.
2021-11-07 23:36:35 +00:00
template<typename U>
Everywhere: Run clang-format
2022-10-16 22:06:11 +00:00
ALWAYS_INLINE ErrorOr(U&& value)
AK: Elaborate the Error constructors a bit The old constraints were making clang mad, so express them in a less complex way.
2022-12-09 16:38:09 +00:00
requires(
requires { T(declval<U>()); } || requires { ErrorType(declval<RemoveCVReference<U>>()); })
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
: m_value_or_error(forward<U>(value))
AK: Add some more ways to construct Error and ErrorOr<T> This is preparation for using Error in the kernel instead of KResult.
2021-11-07 23:36:35 +00:00
{
}
Everywhere: Replace uses of __serenity__ with AK_OS_SERENITY Now that we have OS macros for essentially every supported OS, let's try to use them everywhere.
2022-10-09 21:23:23 +00:00
#ifdef AK_OS_SERENITY
AK: Make Error and ErrorOr<T> work in Lagom as well :^) ErrnoCode is not a thing outside __serenity__, so let's not make assumptions about it existing.
2021-11-06 21:16:50 +00:00
ErrorOr(ErrnoCode code)
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
: m_value_or_error(Error::from_errno(code))
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
{
}
AK: Make Error and ErrorOr<T> work in Lagom as well :^) ErrnoCode is not a thing outside __serenity__, so let's not make assumptions about it existing.
2021-11-06 21:16:50 +00:00
#endif
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK+Tests: Use less space in ErrorOr
2021-12-14 22:02:23 +00:00
T& value()
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
{
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
return m_value_or_error.template get<T>();
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
}
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
T const& value() const { return m_value_or_error.template get<T>(); }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
ErrorType& error() { return m_value_or_error.template get<ErrorType>(); }
ErrorType const& error() const { return m_value_or_error.template get<ErrorType>(); }
bool is_error() const { return m_value_or_error.template has<ErrorType>(); }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK+Tests: Use less space in ErrorOr
2021-12-14 22:02:23 +00:00
T release_value() { return move(value()); }
ErrorType release_error() { return move(error()); }
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
AK: VERIFY inside release_value_but_fixme_should_propagate_errors() While the code did already VERIFY that the ErrorOr holds a value, this was done by Variant, so the error message was just that `has<T>()` is false. This is less helpful than I would like, especially if backtraces are not working and this is all you have to go on. Adding this extra VERIFY means the assertion message (`!is_error()`) is easier to understand.
2022-02-06 12:49:51 +00:00
T release_value_but_fixme_should_propagate_errors()
{
VERIFY(!is_error());
return release_value();
}
AK: Add ErrorOr<T>::release_value_but_fixme_should_propagate_errors() This is an alternative to ErrorOr<T>::release_value() that can be used when converting code to signal that we're releasing the value without error propagation as a way to move forward now. This makes these cases much easier to find later on, once more paths for error propagation are available.
2021-11-06 10:29:32 +00:00
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
private:
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
Variant<T, ErrorType> m_value_or_error;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
};
AK: Allow subclassing Error
2021-11-07 00:30:35 +00:00
template<typename ErrorType>
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
class [[nodiscard]] ErrorOr<void, ErrorType> : public ErrorOr<Empty, ErrorType> {
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
public:
AK: Let ErrorOr<T, E> expose its result/error types `ErrorOr<T, E>::ResultType` can now refer to `T`.
2022-12-10 11:59:20 +00:00
using ResultType = void;
AK: Change ErrorOr to contain a Variant rather than inherit from it GCC seems to get tripped up over this inheritance when converting from an ErrorOr<StringView> to the partially specialized ErrorOr<void>. See the following snippet: NEVER_INLINE ErrorOr<StringView> foo() { auto string = "abc"sv; outln("{:p}", string.characters_without_null_termination()); return string; } NEVER_INLINE ErrorOr<void> bar() { auto string = TRY(foo()); outln("{:p}", string.characters_without_null_termination()); VERIFY(!string.starts_with('#')); return {}; } int main() { MUST(bar()); } On some machines, bar() will contain a StringView whose pointer has had its upper bits set to 0: 0x000000010cafd6f8 0x000000000cafd6f8 I'm not 100% clear on what's happening in the default-generated Variant destructor that causes this. Probably worth investigating further. The error would also be alleviated by making the Variant destructor virtual, but rather than that, let's make ErrorOr simply contain a Variant rather than inherit from it. Fixes #15449.
2022-10-07 12:52:47 +00:00
using ErrorOr<Empty, ErrorType>::ErrorOr;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
};
}
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#if USING_AK_GLOBALLY
AK: Bring AK::Error into the global namespace
2021-11-06 09:34:14 +00:00
using AK::Error;
AK: Add Error and ErrorOr<T> The goal with these is to eventually replace AK::Result, KResult and KResultOr<T> with something that works (and makes sense) in both kernel and userspace. This first cut of Error can be made from an errno code, or from a string literal (StringView)
2021-11-06 00:18:43 +00:00
using AK::ErrorOr;
AK: Make it possible to not `using` AK classes into the global namespace This patch adds the `USING_AK_GLOBALLY` macro which is enabled by default, but can be overridden by build flags. This is a step towards integrating Jakt and AK types.
2022-11-26 11:18:30 +00:00
#endif
Reference in a new issue Copy permalink