clang-win workarounds.

include/boost/cobalt/detail/detached.hpp

@@ -49,30 +49,11 @@ struct detached_promise
 
   [[nodiscard]] detached get_return_object();
 
-  auto await_transform(
+  std::suspend_never await_transform(
       cobalt::this_coro::reset_cancellation_source_t<asio::cancellation_slot> reset) noexcept
   {
-    struct result
-    {
-      detached_promise * promise;
-      asio::cancellation_slot slot;
-
-      constexpr bool await_ready() const noexcept
-      {
-        return true;
-      }
-
-      void await_suspend(std::coroutine_handle<void>) noexcept
-      {
-      }
-
-      auto await_resume()
-      {
-        promise->reset_cancellation_source(std::move(slot));
-      }
-    };
-
-    return result{this, std::move(reset.source)};
+    this->reset_cancellation_source(reset.source);
+    return {};
   }
 
   using executor_type = executor;

include/boost/cobalt/detail/fork.hpp

@@ -136,90 +136,92 @@ struct fork
     cancellation_slot_type get_cancellation_slot() const { return cancel; }
 
     constexpr static std::suspend_never initial_suspend() noexcept {return {};}
-    auto final_suspend()  noexcept
+
+    struct final_awaitable
     {
-      if (cancel.is_connected())
-        cancel.clear();
-      struct awaitable
+      promise_type * self;
+      bool await_ready() noexcept
       {
-        promise_type * self;
-        bool await_ready() noexcept
-        {
-          return self->state->use_count != 1u;
-        }
+        return self->state->use_count != 1u;
+      }
 
-        std::coroutine_handle<void> await_suspend(std::coroutine_handle<promise_type> h) noexcept
-        {
-          auto pp = h.promise().state.detach();
+      std::coroutine_handle<void> await_suspend(std::coroutine_handle<promise_type> h) noexcept
+      {
+        auto pp = h.promise().state.detach();
 
 #if defined(BOOST_COBALT_NO_SELF_DELETE)
-          h.promise().~promise_type();
+        h.promise().~promise_type();
 #else
-          // mem is in a monotonic_resource, this is fine on msvc- gcc doesn't like it though
-          h.destroy();
+        // mem is in a monotonic_resource, this is fine on msvc- gcc doesn't like it though
+        h.destroy();
 #endif
-          pp->use_count--;
-          BOOST_ASSERT(pp->use_count == 0u);
-          if (pp->coro)
-            return pp->coro.release();
-          else
-            return std::noop_coroutine();
-        }
-
-        constexpr static void await_resume() noexcept {}
-      };
-      return awaitable{this};
+        pp->use_count--;
+        BOOST_ASSERT(pp->use_count == 0u);
+        if (pp->coro)
+          return pp->coro.release();
+        else
+          return std::noop_coroutine();
+      }
+
+      constexpr static void await_resume() noexcept {}
+    };
+    final_awaitable final_suspend()  noexcept
+    {
+      if (cancel.is_connected())
+        cancel.clear();
+      return final_awaitable{this};
     }
     void return_void()
     {
     }
 
     template<awaitable<promise_type> Aw>
-    auto await_transform(Aw & aw)
+    struct wrapped_awaitable
     {
-      struct wrapped_awaitable
+      Aw & aw;
+      constexpr static bool await_ready() noexcept
+      {
+        return false;
+      }
+
+      auto await_suspend(std::coroutine_handle<promise_type> h)
       {
-        Aw & aw;
-        constexpr static bool await_ready() noexcept
-        {
-          return false;
-        }
-
-        auto await_suspend(std::coroutine_handle<promise_type> h)
-        {
-          BOOST_ASSERT(h.promise().state->wired_up());
+        BOOST_ASSERT(h.promise().state->wired_up());
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-          if constexpr (requires {aw.await_suspend(h, boost::source_location ());})
+        if constexpr (requires {aw.await_suspend(h, boost::source_location ());})
             return aw.await_suspend(h, h.promise().state->loc);
 #endif
-          return aw.await_suspend(h);
-        }
+        return aw.await_suspend(h);
+      }
 
-        auto await_resume()
-        {
-          return aw.await_resume();
-        }
-      };
+      auto await_resume()
+      {
+        return aw.await_resume();
+      }
+    };
 
-      return wrapped_awaitable{aw};
+    template<awaitable<promise_type> Aw>
+    auto await_transform(Aw & aw)
+    {
+      return wrapped_awaitable<Aw>{aw};
     }
 
-    auto await_transform(wired_up_t)
+    struct wired_up_awaitable
     {
-      struct awaitable
+      promise_type * promise;
+      bool await_ready() const noexcept
       {
-        promise_type * promise;
-        bool await_ready() const noexcept
-        {
-          return promise->state->wired_up();
-        }
-        void await_suspend(std::coroutine_handle<promise_type>)
-        {
-        }
-        constexpr static void await_resume() noexcept {}
-      };
-
-      return awaitable{this};
+        return promise->state->wired_up();
+      }
+      void await_suspend(std::coroutine_handle<promise_type>)
+      {
+      }
+      constexpr static void await_resume() noexcept {}
+    };
+
+    auto await_transform(wired_up_t)
+    {
+      return wired_up_awaitable{this};
     }
 
 

include/boost/cobalt/detail/generator.hpp

@@ -306,45 +306,46 @@ struct generator_promise
   }
 
   std::suspend_never initial_suspend() {return {};}
-  auto final_suspend() noexcept
+
+  struct final_awaitable
   {
-    struct final_awaitable
+    generator_promise * generator;
+    bool await_ready() const noexcept
     {
-      generator_promise * generator;
-      bool await_ready() const noexcept
-      {
-        return generator->receiver && generator->receiver->awaited_from.get() == nullptr;
-      }
-
-      auto await_suspend(std::coroutine_handle<generator_promise> h) noexcept
-      {
-        std::coroutine_handle<void> res = std::noop_coroutine();
-        if (generator->receiver && generator->receiver->awaited_from.get() != nullptr)
-          res = generator->receiver->awaited_from.release();
-        if (generator->receiver)
-            generator->receiver->done = true;
-
+      return generator->receiver && generator->receiver->awaited_from.get() == nullptr;
+    }
 
-        if (auto & rec = h.promise().receiver; rec != nullptr)
-        {
-          if (!rec->done && !rec->exception)
-            rec->exception = detail::completed_unexpected();
-          rec->done = true;
-          rec->awaited_from.reset(nullptr);
-          rec = nullptr;
-        }
+    auto await_suspend(std::coroutine_handle<generator_promise> h) noexcept
+    {
+      std::coroutine_handle<void> res = std::noop_coroutine();
+      if (generator->receiver && generator->receiver->awaited_from.get() != nullptr)
+        res = generator->receiver->awaited_from.release();
+      if (generator->receiver)
+        generator->receiver->done = true;
 
-        detail::self_destroy(h);
-        return res;
-      }
 
-      void await_resume() noexcept
+      if (auto & rec = h.promise().receiver; rec != nullptr)
       {
-        if (generator->receiver)
-          generator->receiver->done = true;
+        if (!rec->done && !rec->exception)
+          rec->exception = detail::completed_unexpected();
+        rec->done = true;
+        rec->awaited_from.reset(nullptr);
+        rec = nullptr;
       }
-    };
 
+      detail::self_destroy(h);
+      return res;
+    }
+
+    void await_resume() noexcept
+    {
+      if (generator->receiver)
+        generator->receiver->done = true;
+    }
+  };
+
+  auto final_suspend() noexcept
+  {
     return final_awaitable{this};
   }
 

include/boost/cobalt/detail/join.hpp

@@ -292,7 +292,6 @@ struct join_ranged_impl
 
   struct awaitable : fork::shared_state
   {
-
     struct dummy
     {
       template<typename ... Args>

include/boost/cobalt/detail/promise.hpp

@@ -320,38 +320,6 @@ struct cobalt_promise
   std::suspend_never initial_suspend()        {return {};}
   auto final_suspend() noexcept
   {
-    struct final_awaitable
-    {
-      cobalt_promise * promise;
-      bool await_ready() const noexcept
-      {
-        return promise->receiver && promise->receiver->awaited_from.get() == nullptr;
-      }
-
-      std::coroutine_handle<void> await_suspend(std::coroutine_handle<cobalt_promise> h) noexcept
-      {
-        std::coroutine_handle<void> res = std::noop_coroutine();
-        if (promise->receiver && promise->receiver->awaited_from.get() != nullptr)
-          res = promise->receiver->awaited_from.release();
-
-
-        if (auto &rec = h.promise().receiver; rec != nullptr)
-        {
-          if (!rec->done && !rec->exception)
-            rec->exception = completed_unexpected();
-          rec->set_done();
-          rec->awaited_from.reset(nullptr);
-          rec = nullptr;
-        }
-        detail::self_destroy(h);
-        return res;
-      }
-
-      void await_resume() noexcept
-      {
-      }
-    };
-
     return final_awaitable{this};
   }
 
@@ -374,6 +342,39 @@ struct cobalt_promise
     }
 
   }
+ private:
+  struct final_awaitable
+  {
+    cobalt_promise * promise;
+    bool await_ready() const noexcept
+    {
+      return promise->receiver && promise->receiver->awaited_from.get() == nullptr;
+    }
+
+    std::coroutine_handle<void> await_suspend(std::coroutine_handle<cobalt_promise> h) noexcept
+    {
+      std::coroutine_handle<void> res = std::noop_coroutine();
+      if (promise->receiver && promise->receiver->awaited_from.get() != nullptr)
+        res = promise->receiver->awaited_from.release();
+
+
+      if (auto &rec = h.promise().receiver; rec != nullptr)
+      {
+        if (!rec->done && !rec->exception)
+          rec->exception = completed_unexpected();
+        rec->set_done();
+        rec->awaited_from.reset(nullptr);
+        rec = nullptr;
+      }
+      detail::self_destroy(h);
+      return res;
+    }
+
+    void await_resume() noexcept
+    {
+    }
+  };
+
 
 };