Merge pull request #8 from steve-downey/assignment-constexp

Make assignment operators constexpr
bemanproject · Jul 21, 2024 · bc1bab9 · bc1bab9
2 parents f00fe6d + 01a0815
commit bc1bab9
Show file tree

Hide file tree

Showing 3 changed files with 113 additions and 8 deletions.
diff --git a/include/Beman/Optional26/optional.hpp b/include/Beman/Optional26/optional.hpp
@@ -332,7 +332,7 @@ class optional {
             value_.~T();
     }
 
-    ~optional()
+    constexpr ~optional()
         requires std::is_trivially_destructible_v<T>
     = default;
 
@@ -426,7 +426,7 @@ class optional {
         }
     }
 
-    optional& operator=(const optional& rhs)
+    constexpr optional& operator=(const optional& rhs)
         requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
                  (!std::is_trivially_copy_assignable_v<T>)
     {
@@ -435,11 +435,11 @@ class optional {
         else if (has_value())
             value_ = rhs.value_;
         else
-            std::construct_at(std::addressof(&value_), rhs.value_);
+            std::construct_at(std::addressof(value_), rhs.value_);
         return *this;
     }
 
-    optional& operator=(const optional&)
+    constexpr optional& operator=(const optional&)
         requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
                      std::is_trivially_copy_constructible_v<T> && std::is_trivially_copy_assignable_v<T>
     = default;
@@ -457,7 +457,7 @@ class optional {
         return *this;
     }
 
-    optional& operator=(optional&&)
+    constexpr optional& operator=(optional&&)
         requires std::is_move_constructible_v<T> && std::is_move_assignable_v<T> &&
                      std::is_trivially_move_constructible_v<T> && std::is_trivially_move_assignable_v<T>
     = default;
@@ -584,7 +584,7 @@ class optional {
     /// Assigns the stored value from `u`, destroying the old value if there
     /// was one.
     template <class U = T>
-    optional& operator=(U&& u)
+    constexpr optional& operator=(U&& u)
         requires enable_assign_forward<T, U>
     {
         if (has_value()) {
@@ -601,7 +601,7 @@ class optional {
     /// Copies the value from `rhs` if there is one. Otherwise resets the
     /// stored value in `*this`.
     template <class U>
-    optional& operator=(const optional<U>& rhs)
+    constexpr optional& operator=(const optional<U>& rhs)
         requires enable_assign_from_other<T, U, const U&>
     {
         if (has_value()) {
@@ -624,7 +624,7 @@ class optional {
     /// Moves the value from `rhs` if there is one. Otherwise resets the stored
     /// value in `*this`.
     template <class U>
-    optional& operator=(optional<U>&& rhs)
+    constexpr optional& operator=(optional<U>&& rhs)
         requires enable_assign_from_other<T, U, U>
     {
         if (has_value()) {

diff --git a/src/Beman/Optional26/tests/optional.t.cpp b/src/Beman/Optional26/tests/optional.t.cpp
@@ -166,6 +166,31 @@ TEST(OptionalTest, AssignmentValue) {
 
     o1 = std::move(o4);
     EXPECT_TRUE(*o1 == 42);
+
+    /*
+      template <class U = T>
+      constexpr optional& operator=(U&& u)
+    */
+    short s = 54;
+    o1      = s;
+    EXPECT_TRUE(*o1 == 54);
+
+    struct not_trivial_copy_assignable {
+        int i_;
+        not_trivial_copy_assignable& operator=(const not_trivial_copy_assignable&);
+    };
+
+
+    /*
+      optional& operator=(const optional& rhs)
+      requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
+      (!std::is_trivially_copy_assignable_v<T>)
+     */
+    beman::optional26::optional<not_trivial_copy_assignable> o5{5};
+    beman::optional26::optional<not_trivial_copy_assignable> o6;
+    o6 = o5;
+    EXPECT_TRUE(o5->i_ == 5);
+
 }
 
 TEST(OptionalTest, Triviality) {
@@ -648,6 +673,7 @@ TEST(ViewMaybeTest, BreathingTest) {
     ASSERT_EQ(*std::begin(m), 1);
 
     m = {};
+    ASSERT_FALSE(m);
     // ASSERT_TRUE(m.size() == 0);
     // ASSERT_TRUE(m1.size() == 1);
 

diff --git a/src/Beman/Optional26/tests/optional_constexpr.t.cpp b/src/Beman/Optional26/tests/optional_constexpr.t.cpp
@@ -1663,3 +1663,82 @@ consteval bool testEmplaceInitList() {
     (std::get<1>(o->t) == 3);
 }
 static_assert(testEmplaceInitList());
+
+consteval bool testAssignment() {
+    beman::optional26::optional<int> o1 = 42;
+    beman::optional26::optional<int> o2 = 12;
+    beman::optional26::optional<int> o3;
+
+    bool retval = true;
+
+    o1 = std::move(o1);
+    retval &= (*o1 == 42);
+
+    o1 = {};
+
+    return retval;
+}
+static_assert(testAssignment());
+
+consteval bool testAssignmentValue() {
+    beman::optional26::optional<int> o1 = 42;
+    beman::optional26::optional<int> o2 = 12;
+    beman::optional26::optional<int> o3;
+
+    bool retval = true;
+
+    o1 = o1;
+    retval &= (*o1 == 42);
+
+    o1 = o2;
+    retval &= (*o1 == 12);
+
+    o1 = o3;
+    retval &= (!o1);
+
+    o1 = 42;
+    retval &= (*o1 == 42);
+
+    o1 = beman::optional26::nullopt;
+    retval &= (!o1);
+
+    o1 = std::move(o2);
+    retval &= (*o1 == 12);
+
+    beman::optional26::optional<short> o4 = 42;
+
+    o1 = o4;
+    retval &= (*o1 == 42);
+
+    o1 = std::move(o4);
+    retval &= (*o1 == 42);
+
+    /*
+      template <class U = T>
+      constexpr optional& operator=(U&& u)
+    */
+
+    short s = 54;
+    o1      = s;
+    retval &= (*o1 == 54);
+
+    struct not_trivial_copy_assignable {
+        int i_;
+        not_trivial_copy_assignable& operator=(const not_trivial_copy_assignable&);
+    };
+
+    /*
+      optional& operator=(const optional& rhs)
+      requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
+      (!std::is_trivially_copy_assignable_v<T>)
+    */
+    beman::optional26::optional<not_trivial_copy_assignable> o5{5};
+    beman::optional26::optional<not_trivial_copy_assignable> o6;
+    o6 = o5;
+    retval &= (o5->i_ == 5);
+
+    return retval;
+
+}
+
+static_assert(testAssignmentValue());