Rework some metaprogramming stuff

7 files changed, 220 insertions, 93 deletions

diff --git a/asl/tests/buffer_tests.cpp b/asl/tests/buffer_tests.cpp
index 5376dc1..b677402 100644
--- a/asl/tests/buffer_tests.cpp
+++ b/asl/tests/buffer_tests.cpp
@@ -1,4 +1,5 @@
 #include "asl/buffer.hpp"

+#include "asl/print.hpp"

 

 #include "asl/testing/testing.hpp"

 

@@ -77,7 +78,6 @@ ASL_TEST(reserve_capacity)
     ASL_TEST_EXPECT(count == 2);

 }

 

-// NOLINTBEGIN(*-pointer-arithmetic)

 ASL_TEST(push)

 {

     asl::buffer<int32_t> b;

@@ -85,28 +85,90 @@ ASL_TEST(push)
 

     b.push(1);

     ASL_TEST_EXPECT(b.size() == 1);

-    ASL_TEST_EXPECT(b.data()[0] == 1);

+    ASL_TEST_EXPECT(b[0] == 1);

 

     b.push(2);

     b.push(3);

     ASL_TEST_EXPECT(b.size() == 3);

-    ASL_TEST_EXPECT(b.data()[0] == 1);

-    ASL_TEST_EXPECT(b.data()[1] == 2);

-    ASL_TEST_EXPECT(b.data()[2] == 3);

+    ASL_TEST_EXPECT(b[0] == 1);

+    ASL_TEST_EXPECT(b[1] == 2);

+    ASL_TEST_EXPECT(b[2] == 3);

 

     b.push(4);

     b.push(5);

     b.push(6);

     b.push(7);

     ASL_TEST_EXPECT(b.size() == 7);

-    ASL_TEST_EXPECT(b.data()[0] == 1);

-    ASL_TEST_EXPECT(b.data()[1] == 2);

-    ASL_TEST_EXPECT(b.data()[2] == 3);

-    ASL_TEST_EXPECT(b.data()[3] == 4);

-    ASL_TEST_EXPECT(b.data()[4] == 5);

-    ASL_TEST_EXPECT(b.data()[5] == 6);

-    ASL_TEST_EXPECT(b.data()[6] == 7);

+    ASL_TEST_EXPECT(b[0] == 1);

+    ASL_TEST_EXPECT(b[1] == 2);

+    ASL_TEST_EXPECT(b[2] == 3);

+    ASL_TEST_EXPECT(b[3] == 4);

+    ASL_TEST_EXPECT(b[4] == 5);

+    ASL_TEST_EXPECT(b[5] == 6);

+    ASL_TEST_EXPECT(b[6] == 7);

+}

+

+struct MoveableType

+{

+    int moved{};

+    int value;

+

+    explicit MoveableType(int x) : value{x} {}

+    MoveableType(const MoveableType&) = delete;

+    MoveableType(MoveableType&& other)  : moved{other.moved + 1}, value{other.value} {}

+    MoveableType& operator=(const MoveableType&) = delete;

+    MoveableType& operator=(MoveableType&&) = delete;

+};

+static_assert(!asl::trivially_copy_constructible<MoveableType>);

+static_assert(!asl::trivially_move_constructible<MoveableType>);

+static_assert(!asl::copyable<MoveableType>);

+static_assert(asl::move_constructible<MoveableType>);

+

+ASL_TEST(push_move)

+{

+    asl::buffer<MoveableType> b;

+

+    static_assert(asl::buffer<MoveableType>::kInlineCapacity > 0);

+

+    b.push(0);

+    ASL_TEST_EXPECT(b[0].value == 0);

+    ASL_TEST_EXPECT(b[0].moved == 0);

+    

+    b.push(1);

+    ASL_TEST_EXPECT(b[0].value == 0);

+    ASL_TEST_EXPECT(b[0].moved == 0);

+    ASL_TEST_EXPECT(b[1].value == 1);

+    ASL_TEST_EXPECT(b[1].moved == 0);

+    

+    b.push(2);

+    ASL_TEST_EXPECT(b[0].value == 0);

+    ASL_TEST_EXPECT(b[0].moved == 1);

+    ASL_TEST_EXPECT(b[1].value == 1);

+    ASL_TEST_EXPECT(b[1].moved == 1);

+    ASL_TEST_EXPECT(b[2].value == 2);

+    ASL_TEST_EXPECT(b[2].moved == 0);

+    

+    b.push(3);

+    ASL_TEST_EXPECT(b[0].value == 0);

+    ASL_TEST_EXPECT(b[0].moved == 1);

+    ASL_TEST_EXPECT(b[1].value == 1);

+    ASL_TEST_EXPECT(b[1].moved == 1);

+    ASL_TEST_EXPECT(b[2].value == 2);

+    ASL_TEST_EXPECT(b[2].moved == 0);

+    ASL_TEST_EXPECT(b[3].value == 3);

+    ASL_TEST_EXPECT(b[3].moved == 0);

+    

+    b.push(4);

+    ASL_TEST_EXPECT(b[0].value == 0);

+    ASL_TEST_EXPECT(b[0].moved == 2);

+    ASL_TEST_EXPECT(b[1].value == 1);

+    ASL_TEST_EXPECT(b[1].moved == 2);

+    ASL_TEST_EXPECT(b[2].value == 2);

+    ASL_TEST_EXPECT(b[2].moved == 1);

+    ASL_TEST_EXPECT(b[3].value == 3);

+    ASL_TEST_EXPECT(b[3].moved == 1);

+    ASL_TEST_EXPECT(b[4].value == 4);

+    ASL_TEST_EXPECT(b[4].moved == 0);

 }

-// NOLINTEND(*-pointer-arithmetic)

 

 // @Todo Test push with non trivial move (non copy) types

diff --git a/asl/tests/maybe_uninit_tests.cpp b/asl/tests/maybe_uninit_tests.cpp
index 3f60558..92999a2 100644
--- a/asl/tests/maybe_uninit_tests.cpp
+++ b/asl/tests/maybe_uninit_tests.cpp
@@ -5,6 +5,6 @@ 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<TriviallyDestructible>>);

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

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

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

 

diff --git a/asl/tests/meta_tests.cpp b/asl/tests/meta_tests.cpp
index fcafe1c..24e9754 100644
--- a/asl/tests/meta_tests.cpp
+++ b/asl/tests/meta_tests.cpp
@@ -13,59 +13,88 @@ static_assert(asl::same_as<asl::select_t<false, int, float>, float>);
 static_assert(asl::same_as<asl::select_t<true, int, float>, int>);

 

 static_assert(asl::default_constructible<int>);

-static_assert(asl::default_constructible<TriviallyDefaultConstructible>);

-static_assert(asl::default_constructible<DefaultConstructible>);

-static_assert(!asl::default_constructible<NonDefaultConstructible>);

+static_assert(asl::default_constructible<TrivialType>);

+static_assert(asl::default_constructible<TrivialTypeDefaultValue>);

 

 static_assert(asl::trivially_default_constructible<int>);

-static_assert(asl::trivially_default_constructible<TriviallyDefaultConstructible>);

-static_assert(!asl::trivially_default_constructible<DefaultConstructible>);

-static_assert(!asl::trivially_default_constructible<NonDefaultConstructible>);

+static_assert(asl::trivially_default_constructible<TrivialType>);

+static_assert(!asl::trivially_default_constructible<TrivialTypeDefaultValue>);

 

 static_assert(asl::copy_constructible<int>);

-static_assert(asl::copy_constructible<TriviallyCopyConstructible>);

-static_assert(asl::copy_constructible<CopyConstructible>);

-static_assert(!asl::copy_constructible<NonCopyConstructible>);

+static_assert(asl::copy_constructible<TrivialType>);

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

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

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

 

 static_assert(asl::trivially_copy_constructible<int>);

-static_assert(asl::trivially_copy_constructible<TriviallyCopyConstructible>);

-static_assert(!asl::trivially_copy_constructible<CopyConstructible>);

-static_assert(!asl::trivially_copy_constructible<NonCopyConstructible>);

+static_assert(asl::trivially_copy_constructible<TrivialType>);

+static_assert(asl::trivially_copy_constructible<TrivialTypeDefaultValue>);

+static_assert(!asl::trivially_copy_constructible<WithDestructor>);

+static_assert(!asl::trivially_copy_constructible<Copyable>);

+static_assert(!asl::trivially_copy_constructible<MoveableOnly>);

+static_assert(!asl::trivially_copy_constructible<Pinned>);

 

 static_assert(asl::move_constructible<int>);

-static_assert(asl::move_constructible<TriviallyMoveConstructible>);

-static_assert(asl::move_constructible<MoveConstructible>);

-static_assert(asl::move_constructible<CopyConstructible>);

-static_assert(!asl::move_constructible<NonMoveConstructible>);

+static_assert(asl::move_constructible<TrivialType>);

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

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

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

 

 static_assert(asl::trivially_move_constructible<int>);

-static_assert(asl::trivially_move_constructible<TriviallyMoveConstructible>);

-static_assert(!asl::trivially_move_constructible<MoveConstructible>);

-static_assert(!asl::trivially_move_constructible<NonMoveConstructible>);

+static_assert(asl::trivially_move_constructible<TrivialType>);

+static_assert(asl::trivially_move_constructible<TrivialTypeDefaultValue>);

+static_assert(!asl::trivially_move_constructible<WithDestructor>);

+static_assert(!asl::trivially_move_constructible<Copyable>);

+static_assert(!asl::trivially_move_constructible<MoveableOnly>);

+static_assert(!asl::trivially_move_constructible<Pinned>);

 

 static_assert(asl::copy_assignable<int>);

-static_assert(asl::copy_assignable<CopyAssignable>);

-static_assert(asl::copy_assignable<TriviallyCopyAssignable>);

-static_assert(!asl::copy_assignable<NonCopyAssignable>);

+static_assert(asl::copy_assignable<TrivialType>);

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

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

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

 

 static_assert(asl::trivially_copy_assignable<int>);

-static_assert(!asl::trivially_copy_assignable<CopyAssignable>);

-static_assert(asl::trivially_copy_assignable<TriviallyCopyAssignable>);

-static_assert(!asl::trivially_copy_assignable<NonCopyAssignable>);

+static_assert(asl::trivially_copy_assignable<TrivialType>);

+static_assert(asl::trivially_copy_assignable<TrivialTypeDefaultValue>);

+static_assert(asl::trivially_copy_assignable<WithDestructor>);

+static_assert(!asl::trivially_copy_assignable<Copyable>);

+static_assert(!asl::trivially_copy_assignable<MoveableOnly>);

+static_assert(!asl::trivially_copy_assignable<Pinned>);

+

+static_assert(asl::copyable<int>);

+static_assert(asl::copyable<TrivialType>);

+static_assert(asl::copyable<Copyable>);

+static_assert(!asl::copyable<MoveableOnly>);

+static_assert(!asl::copyable<Pinned>);

+

+static_assert(asl::moveable<int>);

+static_assert(asl::moveable<TrivialType>);

+static_assert(asl::moveable<Copyable>);

+static_assert(asl::moveable<MoveableOnly>);

+static_assert(!asl::moveable<Pinned>);

 

 static_assert(asl::move_assignable<int>);

-static_assert(asl::move_assignable<MoveAssignable>);

-static_assert(asl::move_assignable<TriviallyMoveAssignable>);

-static_assert(!asl::move_assignable<NonMoveAssignable>);

+static_assert(asl::move_assignable<TrivialType>);

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

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

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

 

 static_assert(asl::trivially_move_assignable<int>);

-static_assert(!asl::trivially_move_assignable<MoveAssignable>);

-static_assert(asl::trivially_move_assignable<TriviallyMoveAssignable>);

-static_assert(!asl::trivially_move_assignable<NonMoveAssignable>);

+static_assert(asl::trivially_move_assignable<TrivialType>);

+static_assert(asl::trivially_move_assignable<TrivialTypeDefaultValue>);

+static_assert(asl::trivially_move_assignable<WithDestructor>);

+static_assert(!asl::trivially_move_assignable<Copyable>);

+static_assert(!asl::trivially_move_assignable<MoveableOnly>);

+static_assert(!asl::trivially_move_assignable<Pinned>);

 

 static_assert(asl::trivially_destructible<int>);

-static_assert(asl::trivially_destructible<TriviallyDestructible>);

-static_assert(!asl::trivially_destructible<HasDestructor>);

+static_assert(asl::trivially_destructible<TrivialType>);

+static_assert(asl::trivially_destructible<TrivialTypeDefaultValue>);

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

+static_assert(asl::trivially_destructible<Copyable>);

+static_assert(asl::trivially_destructible<MoveableOnly>);

+static_assert(asl::trivially_destructible<Pinned>);

 

 static_assert(asl::same_as<int, asl::un_const_t<int>>);

 static_assert(asl::same_as<int, asl::un_const_t<const int>>);

@@ -164,12 +193,6 @@ static_assert(asl::types_count<int, int> == 2);
 static_assert(asl::types_count<int> == 1);

 static_assert(asl::types_count<> == 0);

 

-static_assert(asl::trivially_copyable<int>);

-static_assert(!asl::trivially_copyable<HasDestructor>);

-static_assert(!asl::trivially_copyable<CopyAssignable>);

-static_assert(asl::trivially_copyable<DefaultConstructible>);

-static_assert(asl::trivially_copyable<TriviallyDefaultConstructible>);

-

 class Base {};

 class Derived : public Base {};

 class C {};

diff --git a/asl/tests/option_tests.cpp b/asl/tests/option_tests.cpp
index 8261583..557e2fe 100644
--- a/asl/tests/option_tests.cpp
+++ b/asl/tests/option_tests.cpp
@@ -28,28 +28,28 @@ static_assert(!asl::is_option<int>);
 static_assert(asl::is_option<asl::option<int>>);

 static_assert(asl::is_option<const asl::option<int>>);

 

-static_assert(asl::trivially_destructible<asl::option<TriviallyDestructible>>);

-static_assert(!asl::trivially_destructible<asl::option<HasDestructor>>);

+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::copy_constructible<asl::option<CopyConstructible>>);

-static_assert(!asl::copy_constructible<asl::option<MoveConstructible>>);

-static_assert(!asl::copy_constructible<asl::option<NonMoveConstructible>>);

+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::move_constructible<asl::option<CopyConstructible>>);

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

-static_assert(!asl::move_constructible<asl::option<NonMoveConstructible>>);

+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::copy_assignable<asl::option<CopyAssignable>>);

-static_assert(!asl::copy_assignable<asl::option<MoveAssignable>>);

-static_assert(!asl::copy_assignable<asl::option<NonMoveAssignable>>);

+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::move_assignable<asl::option<CopyAssignable>>);

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

-static_assert(!asl::move_assignable<asl::option<NonMoveAssignable>>);

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

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

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

 

 static_assert(asl::assignable_from<asl::option<Base*>&, asl::option<Derived*>>);

 static_assert(!asl::assignable_from<asl::option<Derived*>&, asl::option<Base*>>);

@@ -70,16 +70,24 @@ static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, asl::optio
 static_assert(asl::convertible_from<asl::option<ImplicitConversion>, asl::option<int>>);

 

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

-static_assert(!asl::trivially_copy_constructible<asl::option<CopyConstructible>>);

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

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

+static_assert(!asl::trivially_copy_constructible<asl::option<Copyable>>);

 

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

-static_assert(!asl::trivially_move_constructible<asl::option<MoveConstructible>>);

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

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

+static_assert(!asl::trivially_move_constructible<asl::option<MoveableOnly>>);

 

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

-static_assert(!asl::trivially_copy_assignable<asl::option<CopyAssignable>>);

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

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

+static_assert(!asl::trivially_copy_assignable<asl::option<Copyable>>);

 

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

-static_assert(!asl::trivially_move_assignable<asl::option<MoveAssignable>>);

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

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

+static_assert(!asl::trivially_move_assignable<asl::option<MoveableOnly>>);

 

 ASL_TEST(make_null)

 {

diff --git a/asl/tests/span_tests.cpp b/asl/tests/span_tests.cpp
index 8b5db76..52e7736 100644
--- a/asl/tests/span_tests.cpp
+++ b/asl/tests/span_tests.cpp
@@ -3,10 +3,10 @@
 #include "asl/tests/test_types.hpp"
 
 static_assert(asl::trivially_destructible<asl::span<int>>);
-static_assert(asl::trivially_destructible<asl::span<HasDestructor>>);
+static_assert(asl::trivially_destructible<asl::span<WithDestructor>>);
 
-static_assert(asl::trivially_copyable<asl::span<int>>);
-static_assert(asl::trivially_copyable<asl::span<NonCopyConstructible>>);
+static_assert(asl::trivially_copy_constructible<asl::span<int>>);
+static_assert(asl::trivially_copy_constructible<asl::span<Pinned>>);
 
 static_assert(asl::size_of<asl::span<int>> == asl::size_of<void*> * 2);
 static_assert(asl::size_of<asl::span<int, 2>> == asl::size_of<void*>);
diff --git a/asl/tests/string_view_tests.cpp b/asl/tests/string_view_tests.cpp
index 708877d..b00da45 100644
--- a/asl/tests/string_view_tests.cpp
+++ b/asl/tests/string_view_tests.cpp
@@ -2,7 +2,7 @@
 #include "asl/testing/testing.hpp"
 
 static_assert(asl::trivially_destructible<asl::string_view>);
-static_assert(asl::trivially_copyable<asl::string_view>);
+static_assert(asl::trivially_copy_constructible<asl::string_view>);
 
 ASL_TEST(default)
 {
diff --git a/asl/tests/test_types.hpp b/asl/tests/test_types.hpp
index f988aec..f91afb3 100644
--- a/asl/tests/test_types.hpp
+++ b/asl/tests/test_types.hpp
@@ -2,28 +2,59 @@
 

 #include "asl/utility.hpp"

 

-struct DefaultConstructible { DefaultConstructible() {} };

-struct TriviallyDefaultConstructible { TriviallyDefaultConstructible() = default; };

-struct NonDefaultConstructible { NonDefaultConstructible() = delete; };

+struct TrivialType

+{

+    int x;

+    TrivialType() = default;

+    TrivialType(const TrivialType&) = default;

+    TrivialType(TrivialType&&) = default;

+    TrivialType& operator=(const TrivialType&) = default;

+    TrivialType& operator=(TrivialType&&) = default;

+    ~TrivialType() = default;

+};

 

-struct CopyConstructible { CopyConstructible(const CopyConstructible&) {} };

-struct TriviallyCopyConstructible { TriviallyCopyConstructible(const TriviallyCopyConstructible&) = default; };

-struct NonCopyConstructible { NonCopyConstructible(const NonCopyConstructible&) = delete; };

+struct TrivialTypeDefaultValue

+{

+    int x{};

+    TrivialTypeDefaultValue() = default;

+    TrivialTypeDefaultValue(const TrivialTypeDefaultValue&) = default;

+    TrivialTypeDefaultValue(TrivialTypeDefaultValue&&) = default;

+    TrivialTypeDefaultValue& operator=(const TrivialTypeDefaultValue&) = default;

+    TrivialTypeDefaultValue& operator=(TrivialTypeDefaultValue&&) = default;

+    ~TrivialTypeDefaultValue() = default;

+};

 

-struct MoveConstructible { MoveConstructible(MoveConstructible&&) {} };

-struct TriviallyMoveConstructible { TriviallyMoveConstructible(TriviallyMoveConstructible&&) = default; };

-struct NonMoveConstructible { NonMoveConstructible(NonMoveConstructible&&) = delete; };

+struct WithDestructor

+{

+    WithDestructor() = default;

+    WithDestructor(const WithDestructor&) = default;

+    WithDestructor(WithDestructor&&) = default;

+    WithDestructor& operator=(const WithDestructor&) = default;

+    WithDestructor& operator=(WithDestructor&&) = default;

+    ~WithDestructor() {} // NOLINT

+};

 

-struct CopyAssignable { CopyAssignable(const CopyAssignable&) {} CopyAssignable& operator=(const CopyAssignable&) { return *this; } };

-struct TriviallyCopyAssignable { TriviallyCopyAssignable& operator=(const TriviallyCopyAssignable&) = default; };

-struct NonCopyAssignable { NonCopyAssignable& operator=(const NonCopyAssignable&) = delete; };

+struct Copyable // NOLINT

+{

+    Copyable(const Copyable&) {} // NOLINT

+    Copyable& operator=(const Copyable&); // NOLINT

+};

 

-struct MoveAssignable { MoveAssignable(MoveAssignable&&) {} MoveAssignable& operator=(MoveAssignable&&) { return *this; } };

-struct TriviallyMoveAssignable { TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default; };

-struct NonMoveAssignable { NonMoveAssignable& operator=(NonMoveAssignable&&) = delete; };

+struct MoveableOnly // NOLINT

+{

+    MoveableOnly(const MoveableOnly&) = delete;

+    MoveableOnly& operator=(const MoveableOnly&) = delete;

+    MoveableOnly(MoveableOnly&&);

+    MoveableOnly& operator=(MoveableOnly&&); // NOLINT

+};

 

-struct TriviallyDestructible { ~TriviallyDestructible() = default; };

-struct HasDestructor { ~HasDestructor() {} };

+struct Pinned // NOLINT

+{

+    Pinned(const Pinned&) = delete;

+    Pinned& operator=(const Pinned&) = delete;

+    Pinned(Pinned&&) = delete;

+    Pinned& operator=(Pinned&&) = delete;

+};

 

 struct DestructorObserver

 {

@@ -31,6 +62,9 @@ struct DestructorObserver
 

     explicit DestructorObserver(bool* destroyed_) : destroyed{destroyed_} {}

 

+    DestructorObserver(const DestructorObserver&) = delete;

+    DestructorObserver& operator=(const DestructorObserver&) = delete;

+

     DestructorObserver(DestructorObserver&& other)

         : destroyed{asl::exchange(other.destroyed, nullptr)}

     {}