fix

Author: poor-circle

async_simple/coro/FutureAwaiter.h

@@ -18,11 +18,12 @@
 
 #ifndef ASYNC_SIMPLE_USE_MODULES
 #include <atomic>
+#include <exception>
 #include <memory>
 #include <type_traits>
-#include <variant>
 #include "async_simple/Future.h"
 #include "async_simple/Signal.h"
+#include "async_simple/Try.h"
 #include "async_simple/coro/Lazy.h"
 #include "async_simple/experimental/coroutine.h"
 
@@ -41,6 +42,10 @@ struct FutureAwaiter {
                                    Executor* ex, Executor::Context ctx,
                                    Slot* cancellationSlot) {
         auto future = std::make_unique<Future<T>>(std::move(future_));
+        future_ = makeReadyFuture<T>(
+            std::make_exception_ptr(async_simple::SignalException(
+                SignalType::Terminate,
+                "FutureAwaiter is only allowed to be called by Lazy")));
         auto state = std::make_shared<std::atomic<bool>>(true);
 
         if (!signalHelper{Terminate}.tryEmplace(
@@ -59,12 +64,12 @@ struct FutureAwaiter {
         }
         auto future_ptr = future.get();
         future_ptr->setContinuation(
-            [continuation, ex, ctx, state = std::move(state),
+            [this, continuation, ex, ctx, state = std::move(state),
              future = std::move(future)](auto&&...) mutable {
                 if (!state->exchange(false)) {
                     return;
                 }
-                future = std::move(future);
+                this->future_ = std::move(*future);
                 if (ex != nullptr) {
                     ex->checkin(continuation, ctx);
                 } else {
@@ -101,10 +106,6 @@ struct FutureAwaiter {
         return true;
     }
     auto await_resume() {
-        if (!future_.valid()) {
-            throw async_simple::SignalException{
-                async_simple::Terminate, "async_simple::Future is canceled!"};
-        }
         if constexpr (!std::is_same_v<T, void>) {
             return std::move(future_.value());
         }

async_simple/coro/test/FutureAwaiterTest.cpp

@@ -100,6 +100,20 @@ TEST_F(FutureAwaiterTest, testWithFutureCancel) {
     syncAwait(collectAll<async_simple::Terminate>(
         lazy().via(&ex1),
         async_simple::coro::sleep(std::chrono::microseconds{10}).via(&ex1)));
+    auto lazy2 = [&]() -> Lazy<> {
+        Promise<int> pr;
+        auto fut = pr.getFuture();
+        sum(1, 1, [pr = std::move(pr)](int val) mutable { pr.setValue(val); });
+        int ret = 0;
+        try {
+            ret = co_await std::move(fut);
+        } catch (...) {
+        }
+        EXPECT_EQ(ret, 2);
+    };
+    syncAwait(collectAll<async_simple::Terminate>(
+        lazy2().via(&ex1),
+        async_simple::coro::sleep(std::chrono::seconds::max()).via(&ex1)));
 }
 
 namespace detail {