Fix assignment of related optional

Fix assignment operator for assign from optional<U> where U is something that
can be bound to a T&. Delete the assignment from an rvalue ref as there is
nothing to move and taking the pointer to temp will dangle.

Author: steve-downey

include/Beman/Optional26/optional.hpp

@@ -1072,10 +1072,16 @@ class optional<T&> {
     template <class U>
     constexpr optional& operator=(const optional<U>& rhs) noexcept {
         static_assert(std::is_constructible_v<std::add_lvalue_reference_t<T>, U>, "Must be able to bind U to T&");
-        value_ = std::addressof(rhs.value());
+        if (rhs.has_value())
+            value_ = std::to_address(rhs);
+        else
+            value_ = nullptr;
         return *this;
     }
 
+    template <class U>
+    constexpr optional& operator=(optional<U>&& rhs)  = delete;
+
     template <class U>
         requires(!detail::is_optional<std::decay_t<U>>)
     constexpr optional& emplace(U&& u) noexcept {

src/Beman/Optional26/tests/CMakeLists.txt

@@ -18,7 +18,8 @@ target_sources(
   optional_ref_monadic.t.cpp
   optional_ref.t.cpp
   optional.t.cpp
-  optional_constexpr.t.cpp)
+  optional_constexpr.t.cpp
+  test_types.cpp)
 
 target_link_libraries(
   beman_optional26_test

src/Beman/Optional26/tests/optional_ref.t.cpp

@@ -553,3 +553,70 @@ TEST(OptionalRefTest, SwapNullIntializedWithValue) {
     EXPECT_EQ(o1.value(), 42);
     EXPECT_TRUE(!o2.has_value());
 }
+
+TEST(OptionalRefTest, AssignFromOptional) {
+    int                               var = 42;
+    beman::optional26::optional<int&> o1  = beman::optional26::nullopt;
+    beman::optional26::optional<int&> o2  = var;
+
+    o2 = o1;
+
+    using beman::optional26::tests::base;
+    using beman::optional26::tests::derived;
+
+    base                               b{1};
+    derived                            d(1, 2);
+    beman::optional26::optional<base&> empty_base;
+    beman::optional26::optional<base&> engaged_base{b};
+
+    beman::optional26::optional<derived&> empty_derived_ref;
+    beman::optional26::optional<derived&> engaged_derived_ref{d};
+
+    beman::optional26::optional<base&> optional_base_ref;
+    optional_base_ref = empty_base;
+    EXPECT_FALSE(optional_base_ref.has_value());
+    optional_base_ref = engaged_base;
+    EXPECT_TRUE(optional_base_ref.has_value());
+
+    optional_base_ref = empty_derived_ref;
+    EXPECT_FALSE(optional_base_ref.has_value());
+
+    optional_base_ref = engaged_derived_ref;
+    EXPECT_TRUE(optional_base_ref.has_value());
+
+    beman::optional26::optional<derived> empty_derived;
+    beman::optional26::optional<derived> engaged_derived{d};
+
+    static_assert(std::is_constructible_v<const base&, derived>);
+
+    beman::optional26::optional<const base&> optional_base_const_ref;
+    optional_base_const_ref = empty_derived;
+    EXPECT_FALSE(optional_base_const_ref.has_value());
+
+    optional_base_const_ref = engaged_derived;
+    EXPECT_TRUE(optional_base_const_ref.has_value());
+
+    if (empty_derived) {
+        optional_base_ref = empty_derived.value();
+    } else {
+        optional_base_ref.reset();
+    }
+    EXPECT_FALSE(optional_base_ref.has_value());
+
+    if (engaged_derived) {
+        optional_base_ref = engaged_derived.value();
+    } else {
+        optional_base_ref.reset();
+    }
+    EXPECT_TRUE(optional_base_ref.has_value());
+
+    derived d2(2, 2);
+    engaged_derived = d2;
+    EXPECT_EQ(optional_base_ref.value().m_i, static_cast<base>(d2).m_i);
+
+    // delete the rvalue ref overload
+    // optional_base_const_ref = beman::optional26::optional<derived>(derived(3, 4));
+    // EXPECT_TRUE(optional_base_ref.has_value());
+    // EXPECT_EQ(*optional_base_ref, derived(3,4));
+
+}

src/Beman/Optional26/tests/test_types.hpp

@@ -4,6 +4,8 @@
 #ifndef BEMAN_OPTIONAL26_TESTS_TEST_TYPES_HPP
 #define BEMAN_OPTIONAL26_TESTS_TEST_TYPES_HPP
 
+#include <compare>
+
 namespace beman::optional26::tests {
 // Classes used in the tests.
 
@@ -31,13 +33,20 @@ struct base {
     int m_i;
     constexpr base() : m_i(0) {}
     constexpr base(int i) : m_i(i) {}
+
+    bool operator!=(const base&) const = default;
+    auto operator<=>(const base&) const = default;
+
 };
 
 // Derived class helper.
 struct derived : public base {
     int m_j;
     constexpr derived() : base(), m_j(0) {}
     constexpr derived(int i, int j) : base(i), m_j(j) {}
+
+    bool operator!=(const derived&) const = default;
+    auto operator<=>(const derived&) const = default;
 };
 
 } // namespace beman::optional26::tests