Merge remote-tracking branch 'origin/main' into shallow-value-category-on-move

Author: jiixyj

include/beman/optional26/optional.hpp

@@ -309,6 +309,8 @@ class optional {
         requires(!std::is_trivially_destructible_v<T>);
 
     // \ref{optional.assign}, assignment
+    constexpr optional& operator=(nullopt_t) noexcept;
+
     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>);
@@ -438,8 +440,7 @@ inline constexpr optional<T>::optional(const optional& rhs)
     requires std::is_copy_constructible_v<T> && (!std::is_trivially_copy_constructible_v<T>)
 {
     if (rhs.has_value()) {
-        std::construct_at(std::addressof(value_), rhs.value_);
-        engaged_ = true;
+        construct(rhs.value_);
     }
 }
 
@@ -448,8 +449,7 @@ inline constexpr optional<T>::optional(optional&& rhs) noexcept(std::is_nothrow_
     requires std::is_move_constructible_v<T> && (!std::is_trivially_move_constructible_v<T>)
 {
     if (rhs.has_value()) {
-        std::construct_at(std::addressof(value_), std::move(rhs.value()));
-        engaged_ = true;
+        construct(std::move(rhs.value_));
     }
 }
 
@@ -481,8 +481,7 @@ inline constexpr optional<T>::optional(const optional<U>& rhs)
              std::is_convertible_v<const U&, T>)
 {
     if (rhs.has_value()) {
-        std::construct_at(std::addressof(value_), rhs.value());
-        engaged_ = true;
+        construct(*rhs);
     }
 }
 
@@ -550,6 +549,12 @@ inline constexpr optional<T>::~optional()
 
 // 22.5.3.4 Assignment[optional.assign]
 
+template <class T>
+inline constexpr optional<T>& optional<T>::operator=(nullopt_t) noexcept {
+    reset();
+    return *this;
+}
+
 template <class T>
 inline constexpr optional<T>& optional<T>::operator=(const optional<T>& rhs)
     requires std::is_copy_constructible_v<T> && std::is_copy_assignable_v<T> &&
@@ -560,7 +565,7 @@ inline constexpr optional<T>& optional<T>::operator=(const optional<T>& rhs)
     else if (has_value())
         value_ = rhs.value_;
     else
-        std::construct_at(std::addressof(value_), rhs.value_);
+        construct(rhs.value_);
     return *this;
 }
 
@@ -575,7 +580,7 @@ optional<T>::operator=(optional<T>&& rhs) noexcept(std::is_nothrow_move_construc
     else if (has_value())
         value_ = std::move(rhs.value_);
     else
-        std::construct_at(std::addressof(value_), std::move(rhs.value_));
+        construct(std::move(rhs.value_));
     return *this;
 }
 

src/beman/optional26/tests/optional.t.cpp

@@ -208,8 +208,38 @@ TEST(OptionalTest, AssignmentValue) {
      */
     beman::optional26::optional<not_trivial_copy_assignable> o5{5};
     beman::optional26::optional<not_trivial_copy_assignable> o6;
+
+    // Copy into empty optional.
     o6 = o5;
-    EXPECT_TRUE(o5->i_ == 5);
+    EXPECT_TRUE(o6);
+    EXPECT_TRUE(o6->i_ == 5);
+
+    // Move into empty optional.
+    o6.reset();
+    o6 = std::move(o5);
+    EXPECT_TRUE(o6);
+    EXPECT_TRUE(o6->i_ == 5);
+
+    // Copy into engaged optional.
+    beman::optional26::optional<not_trivial_copy_assignable> o7{7};
+    o6 = o7;
+    EXPECT_TRUE(o6);
+    EXPECT_TRUE(o6->i_ == 7);
+
+    // Move into engaged optional.
+    beman::optional26::optional<not_trivial_copy_assignable> o8{8};
+    o6 = std::move(o8);
+    EXPECT_TRUE(o6);
+    EXPECT_TRUE(o6->i_ == 8);
+
+    // Copy from empty into engaged optional.
+    o5.reset();
+    o7 = o5;
+    EXPECT_FALSE(o7);
+
+    // Move from empty into engaged optional.
+    o8 = std::move(o5);
+    EXPECT_FALSE(o8);
 }
 
 TEST(OptionalTest, Triviality) {
@@ -869,6 +899,22 @@ TEST(OptionalTest, HashTest) {
     }
 }
 
+TEST(OptionalTest, CanHoldValueOfImmovableType) {
+    using beman::optional26::tests::immovable;
+
+    beman::optional26::optional<immovable> o1(beman::optional26::in_place);
+    EXPECT_TRUE(o1);
+
+    // ...and can reset it with `nullopt`.
+    static_assert(noexcept(o1 = beman::optional26::nullopt));
+    o1 = beman::optional26::nullopt;
+    EXPECT_FALSE(o1);
+
+    // Also, can construct with `nullopt`.
+    beman::optional26::optional<immovable> o2 = beman::optional26::nullopt;
+    EXPECT_FALSE(o2);
+}
+
 // Moving an `optional<T&>` should not move the remote value.
 TEST(OptionalTest, OptionalFromOptionalRef) {
     using beman::optional26::tests::copyable_from_non_const_lvalue_only;

src/beman/optional26/tests/test_types.hpp

@@ -65,6 +65,12 @@ class Point {
     bool operator==(const Point&) const  = default;
 };
 
+struct immovable {
+    explicit immovable()                   = default;
+    immovable(const immovable&)            = delete;
+    immovable& operator=(const immovable&) = delete;
+};
+
 struct copyable_from_non_const_lvalue_only {
     explicit copyable_from_non_const_lvalue_only()                                              = default;
     copyable_from_non_const_lvalue_only(copyable_from_non_const_lvalue_only&)                   = default;