Fix a few mistakes in option, and make it trivial when possible

3 files changed, 28 insertions, 10 deletions

diff --git a/asl/tests/box_tests.cpp b/asl/tests/box_tests.cpp
index 53b6dda..0395e5f 100644
--- a/asl/tests/box_tests.cpp
+++ b/asl/tests/box_tests.cpp
@@ -55,6 +55,8 @@ ASL_TEST(arrow)
 

 ASL_TEST(niche)

 {

+    static_assert(sizeof(asl::box<int>) == sizeof(asl::option<asl::box<int>>));

+    

     asl::option<asl::box<int>> opt;

     ASL_TEST_EXPECT(!opt.has_value());

 

@@ -66,7 +68,7 @@ ASL_TEST(niche)
     ASL_TEST_EXPECT(!opt.has_value());

 

     bool destroyed = false;

-    asl::option<asl::box<DestructorObserver>> opt2 = asl::make_box<DestructorObserver>(&destroyed);

+    asl::option opt2 = asl::make_box<DestructorObserver>(&destroyed);

     ASL_TEST_EXPECT(opt2.has_value());

     ASL_TEST_EXPECT(!destroyed);

 

diff --git a/asl/tests/maybe_uninit_tests.cpp b/asl/tests/maybe_uninit_tests.cpp
index 92999a2..524a10b 100644
--- a/asl/tests/maybe_uninit_tests.cpp
+++ b/asl/tests/maybe_uninit_tests.cpp
@@ -5,6 +5,18 @@ static_assert(asl::layout::of<int>() == asl::layout::of<asl::maybe_uninit<int>>(
 static_assert(asl::size_of<int> == asl::size_of<asl::maybe_uninit<int>>);

 static_assert(asl::align_of<int> == asl::align_of<asl::maybe_uninit<int>>);

 

-static_assert(asl::trivially_destructible<asl::maybe_uninit<TrivialType>>);

-static_assert(!asl::trivially_destructible<asl::maybe_uninit<WithDestructor>>);

+#define TEST_TYPE_PROPERTIES(PRP) \

+    static_assert(asl::PRP<asl::maybe_uninit<TrivialType>> == asl::PRP<TrivialType>); \

+    static_assert(asl::PRP<asl::maybe_uninit<TrivialTypeDefaultValue>> == asl::PRP<TrivialTypeDefaultValue>); \

+    static_assert(asl::PRP<asl::maybe_uninit<WithDestructor>> == asl::PRP<WithDestructor>); \

+    static_assert(asl::PRP<asl::maybe_uninit<Copyable>> == asl::PRP<Copyable>); \

+    static_assert(asl::PRP<asl::maybe_uninit<MoveableOnly>> == asl::PRP<MoveableOnly>); \

+    static_assert(asl::PRP<asl::maybe_uninit<Pinned>> == asl::PRP<Pinned>);

+

+TEST_TYPE_PROPERTIES(trivially_default_constructible);

+TEST_TYPE_PROPERTIES(trivially_copy_constructible);

+TEST_TYPE_PROPERTIES(trivially_move_constructible);

+TEST_TYPE_PROPERTIES(trivially_copy_assignable);

+TEST_TYPE_PROPERTIES(trivially_move_assignable);

+TEST_TYPE_PROPERTIES(trivially_destructible);

 

diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
index 557e2fe..20ee756 100644
--- a/asl/tests/option_tests.cpp
+++ b/asl/tests/option_tests.cpp
@@ -14,14 +14,14 @@ struct NonZero
         ASL_ASSERT(x != 0);

     }

 

-    constexpr explicit NonZero(asl::niche) : value(0) {}

+    constexpr explicit NonZero(asl::niche_t) : value(0) {}

 

-    constexpr bool operator==(asl::niche) const { return value == 0; }

+    constexpr bool operator==(asl::niche_t) const { return value == 0; }

 };

 static_assert(asl::has_niche<NonZero>);

 static_assert(!asl::has_niche<int>);

 

-static_assert(sizeof(asl::option<int>) > sizeof(int));

+static_assert(sizeof(asl::option<int>) >= sizeof(int));

 static_assert(sizeof(asl::option<NonZero>) == sizeof(NonZero));

 

 static_assert(!asl::is_option<int>);
@@ -31,22 +31,26 @@ static_assert(asl::is_option<const asl::option<int>>);
 static_assert(asl::trivially_destructible<asl::option<TrivialType>>);

 static_assert(!asl::trivially_destructible<asl::option<WithDestructor>>);

 

-static_assert(asl::copy_constructible<asl::option<int>>);

+static_assert(asl::trivially_copy_constructible<asl::option<int>>);

+static_assert(asl::trivially_copy_constructible<asl::option<NonZero>>);

 static_assert(asl::copy_constructible<asl::option<Copyable>>);

 static_assert(!asl::copy_constructible<asl::option<MoveableOnly>>);

 static_assert(!asl::copy_constructible<asl::option<Pinned>>);

 

-static_assert(asl::move_constructible<asl::option<int>>);

+static_assert(asl::trivially_move_constructible<asl::option<int>>);

+static_assert(asl::trivially_move_constructible<asl::option<NonZero>>);

 static_assert(asl::move_constructible<asl::option<Copyable>>);

 static_assert(asl::move_constructible<asl::option<MoveableOnly>>);

 static_assert(!asl::move_constructible<asl::option<Pinned>>);

 

-static_assert(asl::copy_assignable<asl::option<int>>);

+static_assert(asl::trivially_copy_assignable<asl::option<int>>);

+static_assert(asl::trivially_copy_assignable<asl::option<NonZero>>);

 static_assert(asl::copy_assignable<asl::option<Copyable>>);

 static_assert(!asl::copy_assignable<asl::option<MoveableOnly>>);

 static_assert(!asl::copy_assignable<asl::option<Pinned>>);

 

-static_assert(asl::move_assignable<asl::option<int>>);

+static_assert(asl::trivially_move_assignable<asl::option<int>>);

+static_assert(asl::trivially_move_assignable<asl::option<NonZero>>);

 static_assert(asl::move_assignable<asl::option<Copyable>>);

 static_assert(asl::move_assignable<asl::option<MoveableOnly>>);

 static_assert(!asl::move_assignable<asl::option<Pinned>>);