mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-04-21 20:15:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

AK: Allow Optional<T> to be used in constant expressions

Browse source
This commit is contained in:
Jonne Ransijn 2025-04-11 15:55:43 +02:00
parent df29a784ba
commit 09e9108750
4 changed files with 233 additions and 86 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

199
AK/Optional.h
View file

@ -46,7 +46,7 @@ template<typename>
class Optional;
struct OptionalNone {
explicit OptionalNone() = default;
explicit ALWAYS_INLINE constexpr OptionalNone() = default;
};
template<typename T, typename Self = Optional<T>>
@ -55,24 +55,24 @@ public:
using ValueType = T;
template<SameAs<OptionalNone> V>
Self& operator=(V)
ALWAYS_INLINE constexpr Self& operator=(V)
{
static_cast<Self&>(*this).clear();
return static_cast<Self&>(*this);
}
[[nodiscard]] ALWAYS_INLINE T* ptr() &
[[nodiscard]] ALWAYS_INLINE constexpr T* ptr() &
{
return static_cast<Self&>(*this).has_value() ? __builtin_launder(reinterpret_cast<T*>(&static_cast<Self&>(*this).value())) : nullptr;
}
[[nodiscard]] ALWAYS_INLINE T const* ptr() const&
[[nodiscard]] ALWAYS_INLINE constexpr T const* ptr() const&
{
return static_cast<Self const&>(*this).has_value() ? __builtin_launder(reinterpret_cast<T const*>(&static_cast<Self const&>(*this).value())) : nullptr;
}
template<typename O = T, typename Fallback = O>
[[nodiscard]] ALWAYS_INLINE O value_or(Fallback const& fallback) const&
[[nodiscard]] ALWAYS_INLINE constexpr O value_or(Fallback const& fallback) const&
{
if (static_cast<Self const&>(*this).has_value())
return static_cast<Self const&>(*this).value();
@ -81,7 +81,7 @@ public:
template<typename O = T, typename Fallback = O>
requires(!IsLvalueReference<O> && !IsRvalueReference<O>)
[[nodiscard]] ALWAYS_INLINE O value_or(Fallback&& fallback) &&
[[nodiscard]] ALWAYS_INLINE constexpr O value_or(Fallback&& fallback) &&
{
if (static_cast<Self&>(*this).has_value())
return move(static_cast<Self&>(*this).value());
@ -89,7 +89,7 @@ public:
}
template<typename Callback, typename O = T>
[[nodiscard]] ALWAYS_INLINE O value_or_lazy_evaluated(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr O value_or_lazy_evaluated(Callback callback) const
{
if (static_cast<Self const&>(*this).has_value())
return static_cast<Self const&>(*this).value();
@ -97,7 +97,7 @@ public:
}
template<typename Callback, typename O = T>
[[nodiscard]] ALWAYS_INLINE Optional<O> value_or_lazy_evaluated_optional(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr Optional<O> value_or_lazy_evaluated_optional(Callback callback) const
{
if (static_cast<Self const&>(*this).has_value())
return static_cast<Self const&>(*this).value();
@ -105,7 +105,7 @@ public:
}
template<typename Callback, typename O = T>
[[nodiscard]] ALWAYS_INLINE ErrorOr<O> try_value_or_lazy_evaluated(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr ErrorOr<O> try_value_or_lazy_evaluated(Callback callback) const
{
if (static_cast<Self const&>(*this).has_value())
return static_cast<Self const&>(*this).value();
@ -113,21 +113,21 @@ public:
}
template<typename Callback, typename O = T>
[[nodiscard]] ALWAYS_INLINE ErrorOr<Optional<O>> try_value_or_lazy_evaluated_optional(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr ErrorOr<Optional<O>> try_value_or_lazy_evaluated_optional(Callback callback) const
{
if (static_cast<Self const&>(*this).has_value())
return static_cast<Self const&>(*this).value();
return TRY(callback());
}
[[nodiscard]] ALWAYS_INLINE T const& operator*() const { return static_cast<Self const&>(*this).value(); }
[[nodiscard]] ALWAYS_INLINE T& operator*() { return static_cast<Self&>(*this).value(); }
[[nodiscard]] ALWAYS_INLINE constexpr T const& operator*() const { return static_cast<Self const&>(*this).value(); }
[[nodiscard]] ALWAYS_INLINE constexpr T& operator*() { return static_cast<Self&>(*this).value(); }
ALWAYS_INLINE T const* operator->() const { return &static_cast<Self const&>(*this).value(); }
ALWAYS_INLINE T* operator->() { return &static_cast<Self&>(*this).value(); }
ALWAYS_INLINE constexpr T const* operator->() const { return &static_cast<Self const&>(*this).value(); }
ALWAYS_INLINE constexpr T* operator->() { return &static_cast<Self&>(*this).value(); }
template<typename F, typename MappedType = decltype(declval<F>()(declval<T&>())), auto IsErrorOr = IsSpecializationOf<MappedType, ErrorOr>, typename OptionalType = Optional<ConditionallyResultType<IsErrorOr, MappedType>>>
ALWAYS_INLINE Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper)
ALWAYS_INLINE constexpr Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper)
{
if constexpr (IsErrorOr) {
if (static_cast<Self&>(*this).has_value())
@ -142,7 +142,7 @@ public:
}
template<typename F, typename MappedType = decltype(declval<F>()(declval<T&>())), auto IsErrorOr = IsSpecializationOf<MappedType, ErrorOr>, typename OptionalType = Optional<ConditionallyResultType<IsErrorOr, MappedType>>>
ALWAYS_INLINE Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper) const
ALWAYS_INLINE constexpr Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper) const
{
if constexpr (IsErrorOr) {
if (static_cast<Self const&>(*this).has_value())
@ -167,13 +167,19 @@ requires(!IsLvalueReference<T>) class [[nodiscard]] Optional<T> : public Optiona
public:
using ValueType = T;
ALWAYS_INLINE Optional() = default;
ALWAYS_INLINE constexpr Optional()
{
construct_null_if_necessairy();
}
template<SameAs<OptionalNone> V>
Optional(V) { }
ALWAYS_INLINE constexpr Optional(V)
{
construct_null_if_necessairy();
}
template<SameAs<OptionalNone> V>
Optional& operator=(V)
ALWAYS_INLINE constexpr Optional& operator=(V)
{
clear();
return *this;
@ -183,78 +189,85 @@ public:
AK_MAKE_CONDITIONALLY_NONMOVABLE(Optional, <T>);
AK_MAKE_CONDITIONALLY_DESTRUCTIBLE(Optional, <T>);
ALWAYS_INLINE Optional(Optional const& other)
ALWAYS_INLINE constexpr Optional(Optional const& other)
requires(!IsTriviallyCopyConstructible<T>)
: m_has_value(other.m_has_value)
{
if (other.has_value())
new (&m_storage) T(other.value());
construct_at<RemoveConst<T>>(&m_storage, other.value());
else
construct_null_if_necessairy();
}
ALWAYS_INLINE Optional(Optional&& other)
ALWAYS_INLINE constexpr Optional(Optional&& other)
requires(!IsTriviallyMoveConstructible<T>)
: m_has_value(other.m_has_value)
{
if (other.has_value())
new (&m_storage) T(other.release_value());
construct_at<RemoveConst<T>>(&m_storage, other.release_value());
else
construct_null_if_necessairy();
}
template<typename U>
requires(IsConstructible<T, U const&> && !IsSpecializationOf<T, Optional> && !IsSpecializationOf<U, Optional> && (!IsLvalueReference<U> || IsTriviallyCopyConstructible<U>)) ALWAYS_INLINE explicit Optional(Optional<U> const& other)
requires(IsConstructible<T, U const&> && !IsSpecializationOf<T, Optional> && !IsSpecializationOf<U, Optional> && (!IsLvalueReference<U> || IsTriviallyCopyConstructible<U>)) ALWAYS_INLINE explicit constexpr Optional(Optional<U> const& other)
: m_has_value(other.has_value())
{
if (other.has_value())
new (&m_storage) T(other.value());
construct_at<RemoveConst<T>>(&m_storage, other.value());
else
construct_null_if_necessairy();
}
template<typename U>
requires(IsConstructible<T, U &&> && !IsSpecializationOf<T, Optional> && !IsSpecializationOf<U, Optional> && (!IsLvalueReference<U> || IsTriviallyMoveConstructible<U>)) ALWAYS_INLINE explicit Optional(Optional<U>&& other)
requires(IsConstructible<T, U &&> && !IsSpecializationOf<T, Optional> && !IsSpecializationOf<U, Optional> && (!IsLvalueReference<U> || IsTriviallyMoveConstructible<U>)) ALWAYS_INLINE explicit constexpr Optional(Optional<U>&& other)
: m_has_value(other.has_value())
{
if (other.has_value())
new (&m_storage) T(other.release_value());
construct_at<RemoveConst<T>>(&m_storage, other.release_value());
else
construct_null_if_necessairy();
}
template<typename U = T>
requires(!IsSame<OptionalNone, RemoveCVReference<U>>)
ALWAYS_INLINE explicit(!IsConvertible<U&&, T>) Optional(U&& value)
ALWAYS_INLINE explicit(!IsConvertible<U&&, T>) constexpr Optional(U&& value)
requires(!IsSame<RemoveCVReference<U>, Optional<T>> && IsConstructible<T, U &&>)
: m_has_value(true)
{
new (&m_storage) T(forward<U>(value));
construct_at<RemoveConst<T>>(&m_storage, forward<U>(value));
}
ALWAYS_INLINE Optional& operator=(Optional const& other)
ALWAYS_INLINE constexpr Optional& operator=(Optional const& other)
requires(!IsTriviallyCopyConstructible<T> || !IsTriviallyDestructible<T>)
{
if (this != &other) {
clear();
m_has_value = other.m_has_value;
if (other.has_value()) {
new (&m_storage) T(other.value());
}
if (other.has_value())
construct_at<RemoveConst<T>>(&m_storage, other.value());
}
return *this;
}
ALWAYS_INLINE Optional& operator=(Optional&& other)
ALWAYS_INLINE constexpr Optional& operator=(Optional&& other)
{
if (this != &other) {
clear();
m_has_value = other.m_has_value;
if (other.has_value()) {
new (&m_storage) T(other.release_value());
}
if (other.has_value())
construct_at<RemoveConst<T>>(&m_storage, other.release_value());
}
return *this;
}
ALWAYS_INLINE ~Optional()
ALWAYS_INLINE constexpr ~Optional()
requires(!IsTriviallyDestructible<T> && IsDestructible<T>)
{
clear();
}
ALWAYS_INLINE void clear()
ALWAYS_INLINE constexpr void clear()
{
if (m_has_value) {
value().~T();
@ -263,41 +276,41 @@ public:
}
template<typename... Parameters>
ALWAYS_INLINE void emplace(Parameters&&... parameters)
ALWAYS_INLINE constexpr void emplace(Parameters&&... parameters)
{
clear();
m_has_value = true;
new (&m_storage) T(forward<Parameters>(parameters)...);
construct_at<RemoveConst<T>>(&m_storage, forward<Parameters>(parameters)...);
}
template<typename Callable>
ALWAYS_INLINE void lazy_emplace(Callable callable)
ALWAYS_INLINE constexpr void lazy_emplace(Callable callable)
{
clear();
m_has_value = true;
new (&m_storage) T { callable() };
construct_at<RemoveConst<T>>(&m_storage, callable());
}
[[nodiscard]] ALWAYS_INLINE bool has_value() const { return m_has_value; }
[[nodiscard]] ALWAYS_INLINE constexpr bool has_value() const { return m_has_value; }
[[nodiscard]] ALWAYS_INLINE T& value() &
[[nodiscard]] ALWAYS_INLINE constexpr T& value() &
{
VERIFY(m_has_value);
return *__builtin_launder(reinterpret_cast<T*>(&m_storage));
return m_storage;
}
[[nodiscard]] ALWAYS_INLINE T const& value() const&
[[nodiscard]] ALWAYS_INLINE constexpr T const& value() const&
{
VERIFY(m_has_value);
return *__builtin_launder(reinterpret_cast<T const*>(&m_storage));
return m_storage;
}
[[nodiscard]] ALWAYS_INLINE T value() &&
[[nodiscard]] ALWAYS_INLINE constexpr T value() &&
{
return release_value();
}
[[nodiscard]] ALWAYS_INLINE T release_value()
[[nodiscard]] ALWAYS_INLINE constexpr T release_value()
{
VERIFY(m_has_value);
T released_value = move(value());
@ -307,7 +320,27 @@ public:
}
private:
alignas(T) u8 m_storage[sizeof(T)];
ALWAYS_INLINE constexpr void construct_null_if_necessairy(bool should_construct = is_constant_evaluated())
{
// OPTIMIZATION: Only construct the `m_null` member when we are constant-evaluating.
// Otherwise, this generates an unnecessairy zero-fill.
#if defined(AK_COMPILER_GCC) || defined(HAS_ADDRESS_SANITIZER)
// NOTE: GCCs -Wuninitialized warning ends up checking this as well.
should_construct = true;
#endif
if (should_construct)
construct_at(&m_null);
}
union {
// FIXME: GCC seems to have an issue with uninitialized unions and non trivial types,
// which forces us to have an equally sized trivial null member in the union
// to pseudo-initialize the union.
struct {
u8 _[sizeof(T)];
} m_null;
RemoveConst<T> m_storage;
};
bool m_has_value { false };
};
@ -325,46 +358,46 @@ requires(IsLvalueReference<T>) class [[nodiscard]] Optional<T> {
public:
using ValueType = T;
ALWAYS_INLINE Optional() = default;
ALWAYS_INLINE constexpr Optional() = default;
template<SameAs<OptionalNone> V>
Optional(V) { }
ALWAYS_INLINE constexpr Optional(V) { }
template<SameAs<OptionalNone> V>
Optional& operator=(V)
ALWAYS_INLINE constexpr Optional& operator=(V)
{
clear();
return *this;
}
template<typename U = T>
ALWAYS_INLINE Optional(U& value)
ALWAYS_INLINE constexpr Optional(U& value)
requires(CanBePlacedInOptional<U&>)
: m_pointer(&value)
{
}
ALWAYS_INLINE Optional(RemoveReference<T>& value)
ALWAYS_INLINE constexpr Optional(RemoveReference<T>& value)
: m_pointer(&value)
{
}
template<typename U>
ALWAYS_INLINE Optional(Optional<U>& other)
ALWAYS_INLINE constexpr Optional(Optional<U>& other)
requires(CanBePlacedInOptional<U>)
: m_pointer(other.ptr())
{
}
template<typename U>
ALWAYS_INLINE Optional(Optional<U> const& other)
ALWAYS_INLINE constexpr Optional(Optional<U> const& other)
requires(CanBePlacedInOptional<U const>)
: m_pointer(other.ptr())
{
}
template<typename U>
ALWAYS_INLINE Optional(Optional<U>&& other)
ALWAYS_INLINE constexpr Optional(Optional<U>&& other)
requires(CanBePlacedInOptional<U>)
: m_pointer(other.ptr())
{
@ -372,7 +405,7 @@ public:
}
template<typename U>
ALWAYS_INLINE Optional& operator=(Optional<U>& other)
ALWAYS_INLINE constexpr Optional& operator=(Optional<U>& other)
requires(CanBePlacedInOptional<U>)
{
m_pointer = other.ptr();
@ -380,7 +413,7 @@ public:
}
template<typename U>
ALWAYS_INLINE Optional& operator=(Optional<U> const& other)
ALWAYS_INLINE constexpr Optional& operator=(Optional<U> const& other)
requires(CanBePlacedInOptional<U const>)
{
m_pointer = other.ptr();
@ -388,7 +421,7 @@ public:
}
template<typename U>
ALWAYS_INLINE Optional& operator=(Optional<U>&& other)
ALWAYS_INLINE constexpr Optional& operator=(Optional<U>&& other)
requires(CanBePlacedInOptional<U> && IsLvalueReference<U>)
{
m_pointer = other.m_pointer;
@ -398,7 +431,7 @@ public:
template<typename U>
requires(!IsSame<OptionalNone, RemoveCVReference<U>>)
ALWAYS_INLINE Optional& operator=(U& value)
ALWAYS_INLINE constexpr Optional& operator=(U& value)
requires(CanBePlacedInOptional<U>)
{
m_pointer = &value;
@ -412,12 +445,12 @@ public:
requires(CanBePlacedInOptional<U>)
= delete;
ALWAYS_INLINE void clear()
ALWAYS_INLINE constexpr void clear()
{
m_pointer = nullptr;
}
[[nodiscard]] ALWAYS_INLINE bool has_value() const { return m_pointer != nullptr; }
[[nodiscard]] ALWAYS_INLINE constexpr bool has_value() const { return m_pointer != nullptr; }
[[nodiscard]] ALWAYS_INLINE RemoveReference<T>* ptr()
{
@ -429,20 +462,20 @@ public:
return m_pointer;
}
[[nodiscard]] ALWAYS_INLINE T value()
[[nodiscard]] ALWAYS_INLINE constexpr T value()
{
VERIFY(m_pointer);
return *m_pointer;
}
[[nodiscard]] ALWAYS_INLINE AddConstToReferencedType<T> value() const
[[nodiscard]] ALWAYS_INLINE constexpr AddConstToReferencedType<T> value() const
{
VERIFY(m_pointer);
return *m_pointer;
}
template<typename U>
requires(IsBaseOf<RemoveCVReference<T>, U>) [[nodiscard]] ALWAYS_INLINE AddConstToReferencedType<T> value_or(U& fallback) const
requires(IsBaseOf<RemoveCVReference<T>, U>) [[nodiscard]] ALWAYS_INLINE constexpr AddConstToReferencedType<T> value_or(U& fallback) const
{
if (m_pointer)
return value();
@ -450,26 +483,26 @@ public:
}
// Note that this ends up copying the value.
[[nodiscard]] ALWAYS_INLINE RemoveCVReference<T> value_or(RemoveCVReference<T> fallback) const
[[nodiscard]] ALWAYS_INLINE constexpr RemoveCVReference<T> value_or(RemoveCVReference<T> fallback) const
{
if (m_pointer)
return value();
return fallback;
}
[[nodiscard]] ALWAYS_INLINE T release_value()
[[nodiscard]] ALWAYS_INLINE constexpr T release_value()
{
return *exchange(m_pointer, nullptr);
}
ALWAYS_INLINE AddConstToReferencedType<T> operator*() const { return value(); }
ALWAYS_INLINE T operator*() { return value(); }
ALWAYS_INLINE constexpr AddConstToReferencedType<T> operator*() const { return value(); }
ALWAYS_INLINE constexpr T operator*() { return value(); }
ALWAYS_INLINE RawPtr<AddConst<RemoveReference<T>>> operator->() const { return &value(); }
ALWAYS_INLINE RawPtr<RemoveReference<T>> operator->() { return &value(); }
// Conversion operators from Optional<T&> -> Optional<T>, implicit when T is trivially copyable.
ALWAYS_INLINE operator Optional<RemoveCVReference<T>>() const
ALWAYS_INLINE constexpr operator Optional<RemoveCVReference<T>>() const
requires(IsTriviallyCopyable<RemoveCVReference<T>>)
{
if (has_value())
@ -478,7 +511,7 @@ public:
}
// Conversion operators from Optional<T&> -> Optional<T>, explicit when T is not trivially copyable, since this is usually a mistake.
ALWAYS_INLINE explicit operator Optional<RemoveCVReference<T>>() const
ALWAYS_INLINE explicit constexpr operator Optional<RemoveCVReference<T>>() const
requires(!IsTriviallyCopyable<RemoveCVReference<T>>)
{
if (has_value())
@ -492,7 +525,7 @@ public:
}
template<typename Callback>
[[nodiscard]] ALWAYS_INLINE T value_or_lazy_evaluated(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr T value_or_lazy_evaluated(Callback callback) const
{
if (m_pointer != nullptr)
return value();
@ -500,7 +533,7 @@ public:
}
template<typename Callback>
[[nodiscard]] ALWAYS_INLINE Optional<T> value_or_lazy_evaluated_optional(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr Optional<T> value_or_lazy_evaluated_optional(Callback callback) const
{
if (m_pointer != nullptr)
return value();
@ -508,7 +541,7 @@ public:
}
template<typename Callback>
[[nodiscard]] ALWAYS_INLINE ErrorOr<T> try_value_or_lazy_evaluated(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr ErrorOr<T> try_value_or_lazy_evaluated(Callback callback) const
{
if (m_pointer != nullptr)
return value();
@ -516,7 +549,7 @@ public:
}
template<typename Callback>
[[nodiscard]] ALWAYS_INLINE ErrorOr<Optional<T>> try_value_or_lazy_evaluated_optional(Callback callback) const
[[nodiscard]] ALWAYS_INLINE constexpr ErrorOr<Optional<T>> try_value_or_lazy_evaluated_optional(Callback callback) const
{
if (m_pointer != nullptr)
return value();
@ -524,7 +557,7 @@ public:
}
template<typename F, typename MappedType = decltype(declval<F>()(declval<T&>())), auto IsErrorOr = IsSpecializationOf<MappedType, ErrorOr>, typename OptionalType = Optional<ConditionallyResultType<IsErrorOr, MappedType>>>
ALWAYS_INLINE Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper)
ALWAYS_INLINE constexpr Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper)
{
if constexpr (IsErrorOr) {
if (m_pointer != nullptr)
@ -539,7 +572,7 @@ public:
}
template<typename F, typename MappedType = decltype(declval<F>()(declval<T&>())), auto IsErrorOr = IsSpecializationOf<MappedType, ErrorOr>, typename OptionalType = Optional<ConditionallyResultType<IsErrorOr, MappedType>>>
ALWAYS_INLINE Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper) const
ALWAYS_INLINE constexpr Conditional<IsErrorOr, ErrorOr<OptionalType>, OptionalType> map(F&& mapper) const
{
if constexpr (IsErrorOr) {
if (m_pointer != nullptr)
@ -558,20 +591,20 @@ private:
};
template<typename T1, typename T2>
ALWAYS_INLINE bool operator==(Optional<T1> const& first, Optional<T2> const& second)
ALWAYS_INLINE constexpr bool operator==(Optional<T1> const& first, Optional<T2> const& second)
{
return first.has_value() == second.has_value()
&& (!first.has_value() || first.value() == second.value());
}
template<typename T1, typename T2>
ALWAYS_INLINE bool operator==(Optional<T1> const& first, T2 const& second)
ALWAYS_INLINE constexpr bool operator==(Optional<T1> const& first, T2 const& second)
{
return first.has_value() && first.value() == second;
}
template<typename T>
ALWAYS_INLINE bool operator==(Optional<T> const& first, OptionalNone)
ALWAYS_INLINE constexpr bool operator==(Optional<T> const& first, OptionalNone)
{
return !first.has_value();
}

2
AK/StdLibExtras.h
View file

@ -10,6 +10,7 @@
#include <AK/Platform.h>
#include <AK/StdLibExtraDetails.h>
#include <memory>
#include <utility>
namespace AK {
@ -31,6 +32,7 @@ requires(AK::Detail::IsIntegral<T>)
template<typename... Args>
void compiletime_fail(Args...);
using std::construct_at;
using std::forward;
using std::move;
}

5
Libraries/LibTest/Macros.h
View file

@ -130,6 +130,9 @@ bool assume(T const& expression, StringView expression_string, SourceLocation lo
return true;
}
template<typename T>
consteval void expect_consteval(T) { }
}
#define EXPECT(...) \
@ -179,6 +182,8 @@ bool assume(T const& expression, StringView expression_string, SourceLocation lo
::Test::set_current_test_result(::Test::TestResult::Failed); \
} while (false)
#define EXPECT_CONSTEVAL(...) ::Test::expect_consteval(__VA_ARGS__)
// To use, specify the lambda to execute in a sub process and verify it exits:
// EXPECT_CRASH("This should fail", []{
// return Test::Crash::Failure::DidNotCrash;

113
Tests/AK/TestOptional.cpp
View file

@ -18,7 +18,7 @@ class NonCopyable {
AK_MAKE_DEFAULT_MOVABLE(NonCopyable);
public:
NonCopyable() { }
constexpr NonCopyable() { }
~NonCopyable() = default;
int x { 13 };
@ -29,7 +29,7 @@ class NonTriviallyCopyable {
AK_MAKE_DEFAULT_MOVABLE(NonTriviallyCopyable);
public:
NonTriviallyCopyable() = default;
constexpr NonTriviallyCopyable() = default;
~NonTriviallyCopyable() = default;
ByteString x { "13" };
@ -40,7 +40,7 @@ class TriviallyCopyable {
AK_MAKE_DEFAULT_MOVABLE(TriviallyCopyable);
public:
TriviallyCopyable() = default;
constexpr TriviallyCopyable() = default;
~TriviallyCopyable() = default;
int x { 13 };
@ -144,6 +144,56 @@ TEST_CASE(comparison_with_numeric_types)
EXPECT_NE(opt1, -2);
}
TEST_CASE(test_constexpr)
{
int i = 13;
NonCopyable dcm {};
EXPECT_CONSTEVAL(Optional<int> {});
EXPECT_CONSTEVAL(Optional<NonCopyable> {});
EXPECT_CONSTEVAL(Optional<int const> {});
EXPECT_CONSTEVAL(Optional<NonCopyable const> {});
EXPECT_CONSTEVAL(Optional<int&> {});
EXPECT_CONSTEVAL(Optional<NonCopyable&> {});
EXPECT_CONSTEVAL(Optional<int const&> {});
EXPECT_CONSTEVAL(Optional<NonCopyable const&> {});
EXPECT_CONSTEVAL(Optional<int> { 13 });
EXPECT_CONSTEVAL(Optional<NonCopyable> { NonCopyable {} });
EXPECT_CONSTEVAL(Optional<int const> { 13 });
EXPECT_CONSTEVAL(Optional<NonCopyable const> { NonCopyable {} });
EXPECT_CONSTEVAL(Optional<int&> { i });
EXPECT_CONSTEVAL(Optional<NonCopyable&> { dcm });
EXPECT_CONSTEVAL(Optional<int const&> { 13 });
EXPECT_CONSTEVAL(Optional<NonCopyable const&> { NonCopyable {} });
static_assert(!Optional<int> {}.has_value());
static_assert(!Optional<NonCopyable> {}.has_value());
static_assert(!Optional<int const> {}.has_value());
static_assert(!Optional<NonCopyable const> {}.has_value());
static_assert(!Optional<int&> {}.has_value());
static_assert(!Optional<NonCopyable&> {}.has_value());
static_assert(!Optional<int const&> {}.has_value());
static_assert(!Optional<NonCopyable const&> {}.has_value());
static_assert(Optional<int> { 13 }.has_value());
static_assert(Optional<NonCopyable> { NonCopyable {} }.has_value());
static_assert(Optional<int const> { 13 }.has_value());
static_assert(Optional<NonCopyable const> { NonCopyable {} }.has_value());
static_assert(Optional<int&> { i }.has_value());
static_assert(Optional<NonCopyable&> { dcm }.has_value());
static_assert(Optional<int const&> { 13 }.has_value());
static_assert(Optional<NonCopyable const&> { NonCopyable {} }.has_value());
static_assert(Optional<int> { 13 }.value() == 13);
static_assert(Optional<NonCopyable> { NonCopyable {} }.value().x == 13);
static_assert(Optional<int const> { 13 }.value() == 13);
static_assert(Optional<int const&> { 13 }.value() == 13);
static_assert(Optional<NonCopyable const&> { NonCopyable {} }.value().x == 13);
static_assert(!(Optional<int> { 1 } = {}).has_value(), "Assigning a `{}` should clear the Optional, even for scalar types^^");
}
TEST_CASE(test_copy_ctor_and_dtor_called)
{
#ifdef AK_HAVE_CONDITIONALLY_TRIVIAL
@ -293,6 +343,63 @@ TEST_CASE(comparison_reference)
EXPECT_NE(opt1, opt3);
}
TEST_CASE(uninitialized_constructor)
{
static bool was_constructed = false;
struct Internal {
Internal() { was_constructed = true; }
};
struct ShouldNotBeDefaultConstructed {
bool m_default_constructed { true };
Internal m_internal;
ShouldNotBeDefaultConstructed() = default;
ShouldNotBeDefaultConstructed(bool)
: m_default_constructed(false)
{
}
};
static_assert(IsConstructible<ShouldNotBeDefaultConstructed>);
Optional<ShouldNotBeDefaultConstructed> opt;
EXPECT(!was_constructed);
EXPECT(!opt.has_value());
opt = ShouldNotBeDefaultConstructed { true };
EXPECT(was_constructed);
EXPECT(opt.has_value());
EXPECT(!opt.value().m_default_constructed);
}
consteval bool test_constexpr()
{
Optional<int> none;
if (none.has_value())
return false;
Optional<int> x;
x = 3;
if (!x.has_value())
return false;
if (x.value() != 3)
return false;
Optional<int> y;
y = x.release_value();
if (!y.has_value())
return false;
if (y.value() != 3)
return false;
if (x.has_value())
return false;
return true;
}
static_assert(test_constexpr());
template<typename To, typename From>
struct CheckAssignments;