fixed move assigns.

closes #159

Author: klemens-morgenstern

include/boost/cobalt/detail/generator.hpp

@@ -104,26 +104,51 @@ struct generator_receiver : generator_receiver_base<Yield, Push>
   {
     if (!lhs.done && !lhs.exception)
     {
-      reference = this;
+      *reference = this;
       lhs.exception = moved_from_exception();
     }
     lhs.done = true;
   }
 
+  generator_receiver& operator=(generator_receiver && lhs) noexcept
+  {
+    if (!done && *reference == this)
+      *reference = nullptr;
+
+    this->pushed_value = std::move(lhs.pushed_value);
+    exception  = std::move(std::move(lhs.exception));
+    done   = std::move(lhs.done);
+    result   = std::move(std::move(lhs.result));
+    result_buffer  = std::move(std::move(lhs.result_buffer));
+    awaited_from   = std::move(std::move(lhs.awaited_from));
+    yield_from   = std::move(std::move(lhs.yield_from));
+    lazy   = std::move(lhs.lazy);
+    reference = lhs.reference;
+    cancel_signal  = std::move(lhs.cancel_signal);
+
+    if (!lhs.done && !lhs.exception && *reference == &lhs)
+    {
+      *reference = this;
+      lhs.exception = moved_from_exception();
+    }
+    lhs.done = true;
+    return *this;
+  }
+
   ~generator_receiver()
   {
-    if (!done && reference == this)
-      reference = nullptr;
+    if (!done && *reference == this)
+      *reference = nullptr;
   }
 
   generator_receiver(generator_receiver * &reference, asio::cancellation_signal & cancel_signal)
-  : reference(reference), cancel_signal(cancel_signal)
+  : reference(&reference), cancel_signal(&cancel_signal)
   {
     reference = this;
   }
 
-  generator_receiver  * &reference;
-  asio::cancellation_signal & cancel_signal;
+  generator_receiver  **reference;
+  asio::cancellation_signal * cancel_signal;
 
   using yield_awaitable = generator_yield_awaitable<Yield, Push>;
 
@@ -185,7 +210,7 @@ struct generator_receiver : generator_receiver_base<Yield, Push>
 
       if constexpr (requires (Promise p) {p.get_cancellation_slot();})
         if ((cl = h.promise().get_cancellation_slot()).is_connected())
-          cl.emplace<forward_cancellation>(self->cancel_signal);
+          cl.emplace<forward_cancellation>(*self->cancel_signal);
 
       self->awaited_from.reset(h.address());
 

include/boost/cobalt/detail/promise.hpp

@@ -120,22 +120,43 @@ struct promise_receiver : promise_value_holder<T>
   {
     if (!done && !exception)
     {
-      reference = this;
+      *reference = this;
       lhs.exception = moved_from_exception();
     }
 
     lhs.done = true;
+  }
+
+  promise_receiver& operator=(promise_receiver && lhs) noexcept
+  {
+    if (!done && *reference == this)
+      *reference = nullptr;
 
+    promise_value_holder<T>::operator= (std::move(lhs));
+    exception = std::move(lhs.exception);
+    done = lhs.done;
+    awaited_from = std::move(lhs.awaited_from);
+    reference = lhs.reference;
+    cancel_signal = lhs.cancel_signal;
+
+    if (!done && !exception && *reference == &lhs)
+    {
+      *reference = this;
+      lhs.exception = moved_from_exception();
+    }
+
+    lhs.done = true;
+    return *this;
   }
 
   ~promise_receiver()
   {
-    if (!done && reference == this)
-      reference = nullptr;
+    if (!done && *reference == this)
+      *reference = nullptr;
   }
 
   promise_receiver(promise_receiver * &reference, asio::cancellation_signal & cancel_signal)
-      : reference(reference), cancel_signal(cancel_signal)
+      : reference(&reference), cancel_signal(&cancel_signal)
   {
     reference = this;
   }
@@ -176,7 +197,7 @@ struct promise_receiver : promise_value_holder<T>
 
       if constexpr (requires (Promise p) {p.get_cancellation_slot();})
         if ((cl = h.promise().get_cancellation_slot()).is_connected())
-          cl.emplace<forward_cancellation>(self->cancel_signal);
+          cl.emplace<forward_cancellation>(*self->cancel_signal);
 
       self->awaited_from.reset(h.address());
       return true;
@@ -232,8 +253,8 @@ struct promise_receiver : promise_value_holder<T>
     }
   };
 
-  promise_receiver  * &reference;
-  asio::cancellation_signal & cancel_signal;
+  promise_receiver  ** reference;
+  asio::cancellation_signal * cancel_signal;
 
   awaitable get_awaitable() {return awaitable{this};}
 

include/boost/cobalt/detail/task.hpp

@@ -109,7 +109,7 @@ struct task_receiver : task_value_holder<T>
   }
 
   task_receiver() = default;
-  task_receiver(task_receiver && lhs)
+  task_receiver(task_receiver && lhs) noexcept
       : task_value_holder<T>(std::move(lhs)),
         exception(std::move(lhs.exception)), done(lhs.done), awaited_from(std::move(lhs.awaited_from)),
         promise(lhs.promise)
@@ -123,6 +123,34 @@ struct task_receiver : task_value_holder<T>
     lhs.done = true;
   }
 
+  task_receiver& operator=(task_receiver && lhs) noexcept
+  {
+    if (!done && promise && promise->receiver == this)
+    {
+      promise->receiver = nullptr;
+      if (!promise->started)
+        std::coroutine_handle<task_promise<T>>::from_promise(*promise).destroy();
+    }
+
+    task_value_holder<T>::operator=(std::move(lhs));
+
+    exception = std::move(lhs.exception);
+    done = lhs.done;
+    awaited_from = std::move(lhs.awaited_from);
+    promise = lhs.promise;
+
+
+    if (!done && !exception)
+    {
+      promise->receiver = this;
+      lhs.exception = moved_from_exception();
+    }
+
+    lhs.done = true;
+    return *this;
+  }
+
+
   ~task_receiver()
   {
     if (!done && promise && promise->receiver == this)

include/boost/cobalt/generator.hpp

@@ -89,8 +89,8 @@ inline generator<Yield, Push>::operator bool() const
 template<typename Yield, typename Push >
 inline void generator<Yield, Push>::cancel(asio::cancellation_type ct)
 {
-  if (!receiver_.done && receiver_.reference == &receiver_)
-    receiver_.cancel_signal.emit(ct);
+  if (!receiver_.done && *receiver_.reference == &receiver_)
+    receiver_.cancel_signal->emit(ct);
 }
 
 template<typename Yield, typename Push >

include/boost/cobalt/promise.hpp

@@ -91,6 +91,8 @@ promise<T>& promise<T>::operator=(promise && lhs) noexcept
     cancel();
   receiver_ = std::move(lhs.receiver_);
   attached_ = std::exchange(lhs.attached_, false);
+
+  return *this;
 }
 
 template<typename T>
@@ -106,8 +108,8 @@ template<typename T>
 inline
 void promise<T>::cancel(asio::cancellation_type ct)
 {
-  if (!receiver_.done && receiver_.reference == &receiver_)
-    receiver_.cancel_signal.emit(ct);
+  if (!receiver_.done && *receiver_.reference == &receiver_)
+    receiver_.cancel_signal->emit(ct);
 }
 
 template<typename T>

test/generator.cpp

@@ -43,10 +43,10 @@ CO_TEST_CASE(generator_int)
   while (g)
     BOOST_CHECK(i ++ == co_await g);
 
-
-
   BOOST_CHECK(i == 11);
 
+  g = gen();
+
   co_return ;
 }
 

test/promise.cpp

@@ -34,8 +34,10 @@ cobalt::promise<double> test2(int i)
 
 cobalt::promise<int> test1(asio::any_io_executor exec)
 {
-    co_await test2(42);
-    co_await test2(42);
+    auto t1 = test2(42);
+    co_await t1;
+    t1 = test2(42);
+    co_await t1;
 
     BOOST_CHECK(test2(42).get() == 42);
 
@@ -85,7 +87,7 @@ cobalt::promise<std::size_t> delay_r(asio::io_context &ctx, std::size_t ms,
 
 cobalt::promise<std::size_t> delay_r(asio::any_io_executor exec, std::size_t ms)
 {
-   auto tim = cobalt::use_op.as_default_on(asio::steady_timer(exec, std::chrono::milliseconds{ms}));
+  auto tim = cobalt::use_op.as_default_on(asio::steady_timer(exec, std::chrono::milliseconds{ms}));
   co_await tim.async_wait();
   co_return ms;
 }
@@ -159,4 +161,5 @@ CO_TEST_CASE(move_only)
   co_await pro_move_only_test();
 }
 
+
 BOOST_AUTO_TEST_SUITE_END();

test/task.cpp

@@ -24,6 +24,7 @@
 #include <boost/core/ignore_unused.hpp>
 
 #include <new>
+#include <deque>
 
 using namespace boost;
 
@@ -45,8 +46,10 @@ cobalt::task<double> test2(int i)
 
 cobalt::task<int> test1()
 {
-    co_await test2(42);
-    co_await test2(42);
+    auto t = test2(42);
+    co_await t;
+    t = test2(42);
+    co_await t;
 
 
     co_await asio::post(co_await cobalt::this_coro::executor, cobalt::use_task);
@@ -312,5 +315,14 @@ CO_TEST_CASE(move_only)
   co_await task_move_only_test();
 }
 
+static_assert(std::is_move_assignable_v<cobalt::task<void>>);
+static_assert(std::is_move_assignable_v<cobalt::task<int>>);
+static_assert(std::is_move_constructible_v<cobalt::task<void>>);
+static_assert(std::is_move_constructible_v<cobalt::task<int>>);
+
+void foo(std::deque<boost::cobalt::task<void>> & session_promisses)
+{
+  session_promisses.erase(session_promisses.begin() + 1234);
+}
 
 BOOST_AUTO_TEST_SUITE_END();