Attempt to conditionally delete assignment

CMakeLists.txt

@@ -10,6 +10,7 @@ target_include_directories(Catch INTERFACE ${CATCH_INCLUDE_DIR})
 # Make test executable
 set(TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/tests/main.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/tests/extensions.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/tests/assignment.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/tests/constructors.cpp)
 
 add_executable(tests ${TEST_SOURCES})

expected.hpp

@@ -399,6 +399,50 @@ template <class E> struct expected_storage_base<void, E, false, false> {
 
 // TODO, conditionally delete things
     template <class T, class E> struct expected_ctor_base {};
+    template <class T, class E,
+              bool = (std::is_copy_assignable<T>::value && std::is_copy_assignable<E>::value &&
+                      std::is_copy_constructible<E>::value && std::is_copy_constructible<T>::value &&
+                      std::is_nothrow_move_constructible<E>::value),
+              bool = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value &&
+                      std::is_nothrow_move_constructible<E>::value && std::is_nothrow_move_assignable<E>::value)>
+    struct expected_assign_base {
+        expected_assign_base() = default;
+        ~expected_assign_base() = default;
+        expected_assign_base(const expected_assign_base&) = default;
+        expected_assign_base(expected_assign_base&&) noexcept = default;
+        expected_assign_base& operator=(const expected_assign_base&) = default;
+        expected_assign_base& operator=(expected_assign_base&&) noexcept = default;
+    };
+
+    template <class T, class E>
+    struct expected_assign_base<T,E,true,false> {
+        expected_assign_base() = default;
+        ~expected_assign_base() = default;
+        expected_assign_base(const expected_assign_base&) = default;
+        expected_assign_base(expected_assign_base&&) noexcept = default;
+        expected_assign_base& operator=(const expected_assign_base&) = default;
+        expected_assign_base& operator=(expected_assign_base&&) noexcept = delete;
+    };
+
+    template <class T, class E>
+    struct expected_assign_base<T,E,false,true> {
+        expected_assign_base() = default;
+        ~expected_assign_base() = default;
+        expected_assign_base(const expected_assign_base&) = default;
+        expected_assign_base(expected_assign_base&&) noexcept = default;
+        expected_assign_base& operator=(const expected_assign_base&) = delete;
+        expected_assign_base& operator=(expected_assign_base&&) noexcept = default;
+    };
+
+    template <class T, class E>
+    struct expected_assign_base<T,E,false,false> {
+        expected_assign_base() = default;
+        ~expected_assign_base() = default;
+        expected_assign_base(const expected_assign_base&) = default;
+        expected_assign_base(expected_assign_base&&) noexcept = default;
+        expected_assign_base& operator=(const expected_assign_base&) = delete;
+        expected_assign_base& operator=(expected_assign_base&&) noexcept = delete;
+    };
 } // namespace detail
 
 template <class E> class bad_expected_access : public std::exception {
@@ -419,7 +463,9 @@ private:
 };
 
 template <class T, class E>
-class expected : private detail::expected_storage_base<T, E> {
+class expected : private detail::expected_storage_base<T, E>,
+                 private detail::expected_assign_base<T, E>
+{
   static_assert(!std::is_reference<T>::value, "T must not be a reference");
   static_assert(!std::is_same<T, std::remove_cv<in_place_t>>::value,
                 "T must not be in_place_t");
@@ -814,13 +860,15 @@ public:
     expected& operator=(expected&& rhs) {
         return assign(std::move(rhs));
     }
+
     template <class U = T,
               detail::enable_if_t<
                   (!std::is_same<expected<T,E>, detail::decay_t<U>>::value &&
                    !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value &&
                    std::is_constructible<T, U>::value &&
                    std::is_assignable<T&, U>::value &&
-                   std::is_nothrow_move_constructible<E>::value)>* = nullptr,                 detail::enable_if_t<std::is_nothrow_constructible<T, U&&>::value>* = nullptr>
+                   std::is_nothrow_move_constructible<E>::value)>* = nullptr,
+              detail::enable_if_t<std::is_nothrow_constructible<T, U&&>::value>* = nullptr>
    expected &operator=(U &&v) {
         if (has_value()) {
             val() = std::forward<U>(v);
@@ -864,7 +912,7 @@ public:
 
 
     template <class G = E,
-              detail::enable_if_t<std::is_nothrow_copy_constructible<E>::value && std::is_assignable<E&, E>::value>* = nullptr>
+              detail::enable_if_t<std::is_nothrow_copy_constructible<G>::value && std::is_assignable<G&, G>::value>* = nullptr>
         expected &operator=(const unexpected<G> &rhs) {
         if (!has_value()) {
             err() = rhs;
@@ -879,7 +927,7 @@ public:
     }
 
     template <class G = E,
-              detail::enable_if_t<std::is_nothrow_move_constructible<E>::value && std::is_move_assignable<E>::value>* = nullptr>
+              detail::enable_if_t<std::is_nothrow_move_constructible<G>::value && std::is_move_assignable<G>::value>* = nullptr>
         expected &operator=(unexpected<G> && rhs) noexcept {
         if (!has_value()) {
             err() = std::move(rhs);

tests/assignment.cpp

@@ -0,0 +1,76 @@
+#include "catch.hpp"
+#include "expected.hpp"
+
+TEST_CASE("Simple assignment", "[assignment.simple]") {
+    tl::expected<int,int> e1 = 42;
+    tl::expected<int,int> e2 = 17;
+    tl::expected<int,int> e3 = 21;
+    tl::expected<int,int> e4 = tl::make_unexpected(42);
+    tl::expected<int,int> e5 = tl::make_unexpected(17);
+    tl::expected<int,int> e6 = tl::make_unexpected(21);
+
+    e1 = e2;
+    REQUIRE(e1);
+    REQUIRE(*e1 == 17);
+    REQUIRE(e2);
+    REQUIRE(*e2 == 17);
+
+    e1 = std::move(e2);
+    REQUIRE(e1);
+    REQUIRE(*e1 == 17);
+    REQUIRE(e2);
+    REQUIRE(*e2 == 17);
+
+    e1 = 42;
+    REQUIRE(e1);
+    REQUIRE(*e1 == 42);
+
+    auto unex = tl::make_unexpected(12);
+    e1 = unex;
+    REQUIRE(!e1);
+    REQUIRE(e1.error() == 12);
+
+    e1 = tl::make_unexpected(42);
+    REQUIRE(!e1);
+    REQUIRE(e1.error() == 42);
+
+    e1 = e3;
+    REQUIRE(e1);
+    REQUIRE(*e1 == 21);
+
+    e4 = e5;
+    REQUIRE(!e4);
+    REQUIRE(e4.error() == 17);
+
+    e4 = std::move(e6);
+    REQUIRE(!e4);
+    REQUIRE(e4.error() == 21);
+
+    e4 = e1;
+    REQUIRE(e4);
+    REQUIRE(*e4 == 21);
+
+}
+
+TEST_CASE("Assignment deletion", "[assignment.deletion]") {
+    struct has_all {
+        has_all() = default;
+        has_all(const has_all&) = default;
+        has_all(has_all&&) noexcept = default;
+        has_all& operator=(const has_all&) = default;
+    };
+
+    tl::expected<has_all, has_all> e1 = {};
+    tl::expected<has_all, has_all> e2 = {};
+    e1 = e2;
+
+    struct except_move {
+        except_move() = default;
+        except_move(const except_move&) = default;
+        except_move(except_move&&) noexcept(false) {};
+        except_move& operator=(const except_move&) = default;
+    };
+    tl::expected<except_move, except_move> e3 = {};
+    tl::expected<except_move, except_move> e4 = {};
+    e3 = e4;
+}

tests/emplace.cpp

@@ -0,0 +1,4 @@
+#include "catch.hpp"
+#include "expected.hpp"
+
+TEST_CASE("Emplace", "[emplace]") {