Merge branch 'main' into unused-parameter

Author: ericniebler

include/exec/at_coroutine_exit.hpp

@@ -119,8 +119,8 @@ namespace exec {
     inline constexpr __die_on_stop_t __die_on_stop;
 
     template <class _Promise>
-    concept __has_continuation = requires(_Promise& __promise, __continuation_handle<> __c) {
-      { __promise.continuation() } -> convertible_to<__continuation_handle<>>;
+    concept __has_continuation = requires(_Promise& __promise, __coroutine_handle<> __c) {
+      { __promise.continuation() } -> convertible_to<__coroutine_handle<>>;
       { __promise.set_continuation(__c) };
     };
 

include/exec/on_coro_disposition.hpp

@@ -21,7 +21,7 @@
 #include "../stdexec/execution.hpp"
 #include "../stdexec/coroutine.hpp"
 #include "task.hpp"
-#include "inline_scheduler.hpp"
+#include "inline_scheduler.hpp" // IWYU pragma: keep
 #include "any_sender_of.hpp"
 
 #include <exception>

include/exec/task.hpp

@@ -494,22 +494,6 @@ namespace exec {
         return __task_awaitable<>{std::exchange(__coro_, {})};
       }
 
-      // From the list of types [_Ty], remove any types that are void, and send
-      //   the resulting list to __qf<set_value_t>, which uses the list of types
-      //   as arguments of a function type. In other words, set_value_t() if _Ty
-      //   is void, and set_value_t(_Ty) otherwise.
-      using __set_value_sig_t = __minvoke<__mremove<void, __qf<set_value_t>>, _Ty>;
-
-      // Specify basic_task's completion signatures
-      //   This is only necessary when basic_task is not generally awaitable
-      //   owing to constraints imposed by its _Context parameter.
-      using __task_traits_t =
-        completion_signatures<__set_value_sig_t, set_error_t(std::exception_ptr), set_stopped_t()>;
-
-      auto get_completion_signatures(__ignore = {}) const -> __task_traits_t {
-        return {};
-      }
-
       explicit basic_task(__coro::coroutine_handle<promise_type> __coro) noexcept
         : __coro_(__coro) {
       }

include/stdexec/__detail/__with_awaitable_senders.hpp

@@ -19,23 +19,24 @@
 
 #include "__as_awaitable.hpp"
 #include "__concepts.hpp"
+#include "../coroutine.hpp" // IWYU pragma: keep for __coro::coroutine_handle
 
 #include <exception>
 
 namespace stdexec {
 #if !STDEXEC_STD_NO_COROUTINES()
   namespace __was {
     template <class _Promise = void>
-    class __continuation_handle;
+    class __coroutine_handle;
 
     template <>
-    class __continuation_handle<void> {
+    class __coroutine_handle<void> : __coro::coroutine_handle<> {
      public:
-      __continuation_handle() = default;
+      __coroutine_handle() = default;
 
       template <class _Promise>
-      __continuation_handle(__coro::coroutine_handle<_Promise> __coro) noexcept
-        : __coro_(__coro) {
+      __coroutine_handle(__coro::coroutine_handle<_Promise> __coro) noexcept
+        : __coro::coroutine_handle<>(__coro) {
         if constexpr (requires(_Promise& __promise) { __promise.unhandled_stopped(); }) {
           __stopped_callback_ = [](void* __address) noexcept -> __coro::coroutine_handle<> {
             // This causes the rest of the coroutine (the part after the co_await
@@ -53,43 +54,46 @@ namespace stdexec {
 
       [[nodiscard]]
       auto handle() const noexcept -> __coro::coroutine_handle<> {
-        return __coro_;
+        return *this;
       }
 
       [[nodiscard]]
       auto unhandled_stopped() const noexcept -> __coro::coroutine_handle<> {
-        return __stopped_callback_(__coro_.address());
+        return __stopped_callback_(address());
       }
 
      private:
       using __stopped_callback_t = __coro::coroutine_handle<> (*)(void*) noexcept;
 
-      __coro::coroutine_handle<> __coro_{};
       __stopped_callback_t __stopped_callback_ = [](void*) noexcept -> __coro::coroutine_handle<> {
         std::terminate();
       };
     };
 
     template <class _Promise>
-    class __continuation_handle {
+    class __coroutine_handle : public __coroutine_handle<> {
      public:
-      __continuation_handle() = default;
+      __coroutine_handle() = default;
 
-      __continuation_handle(__coro::coroutine_handle<_Promise> __coro) noexcept
-        : __continuation_{__coro} {
+      __coroutine_handle(__coro::coroutine_handle<_Promise> __coro) noexcept
+        : __coroutine_handle<>{__coro} {
       }
 
-      auto handle() const noexcept -> __coro::coroutine_handle<_Promise> {
-        return __coro::coroutine_handle<_Promise>::from_address(__continuation_.handle().address());
+      static auto from_promise(_Promise& __promise) noexcept -> __coroutine_handle {
+        return __coroutine_handle(__coro::coroutine_handle<_Promise>::from_promise(__promise));
       }
 
-      [[nodiscard]]
-      auto unhandled_stopped() const noexcept -> __coro::coroutine_handle<> {
-        return __continuation_.unhandled_stopped();
+      auto promise() const noexcept -> _Promise& {
+        return __coro::coroutine_handle<_Promise>::from_address(address()).promise();
       }
 
-     private:
-      __continuation_handle<> __continuation_{};
+      auto handle() const noexcept -> __coro::coroutine_handle<_Promise> {
+        return __coro::coroutine_handle<_Promise>::from_address(address());
+      }
+
+      operator __coro::coroutine_handle<_Promise>() const noexcept {
+        return handle();
+      }
     };
 
     struct __with_awaitable_senders_base {
@@ -99,12 +103,12 @@ namespace stdexec {
         __continuation_ = __hcoro;
       }
 
-      void set_continuation(__continuation_handle<> __continuation) noexcept {
+      void set_continuation(__coroutine_handle<> __continuation) noexcept {
         __continuation_ = __continuation;
       }
 
       [[nodiscard]]
-      auto continuation() const noexcept -> __continuation_handle<> {
+      auto continuation() const noexcept -> __coroutine_handle<> {
         return __continuation_;
       }
 
@@ -113,7 +117,7 @@ namespace stdexec {
       }
 
      private:
-      __continuation_handle<> __continuation_{};
+      __coroutine_handle<> __continuation_{};
     };
 
     template <class _Promise>
@@ -127,6 +131,6 @@ namespace stdexec {
   } // namespace __was
 
   using __was::with_awaitable_senders;
-  using __was::__continuation_handle;
+  using __was::__coroutine_handle;
 #endif
 } // namespace stdexec