{FOLD]

Author: vinniefalco

include/boost/capy/io/write_now.hpp

@@ -114,37 +114,23 @@ class write_now
             std::stop_token token_;
             bool done_ = false;
 
-            // GCC 14 ICE bisection: trivially destructible
-            // aggregate with full interface
+            // BISECT: identical to std::suspend_always
+            // but a different type. If this ICEs, GCC rejects
+            // ANY non-std awaiter from IoAwaitable branch.
             struct erased_io_awaiter
             {
-                void* inner_;
-                promise_type* p_;
-                bool (*ready_)(void*);
-                coro (*suspend_)(
-                    void*, coro,
-                    executor_ref, std::stop_token);
-                io_result<std::size_t> (*resume_)(void*);
-                void (*destroy_)(void*);
-
-                bool await_ready()
+                bool await_ready() noexcept
                 {
-                    return ready_(inner_);
+                    return false;
                 }
 
-                coro await_suspend(coro h)
+                void await_suspend(
+                    std::coroutine_handle<>) noexcept
                 {
-                    return suspend_(
-                        inner_, h,
-                        p_->ex_, p_->token_);
                 }
 
-                io_result<std::size_t> await_resume()
+                void await_resume() noexcept
                 {
-                    auto r = resume_(inner_);
-                    destroy_(inner_);
-                    inner_ = nullptr;
-                    return r;
                 }
             };
 
@@ -213,28 +199,10 @@ class write_now
                 if constexpr (IoAwaitable<decayed>)
                 {
 #if BOOST_CAPY_WRITE_NOW_WORKAROUND
-                    return erased_io_awaiter{
-                        new decayed(std::forward<A>(a)),
-                        this,
-                        +[](void* v) -> bool {
-                            return static_cast<decayed*>(
-                                v)->await_ready();
-                        },
-                        +[](void* v, coro h,
-                            executor_ref ex,
-                            std::stop_token tok) -> coro {
-                            return detail::call_await_suspend(
-                                static_cast<decayed*>(v),
-                                h, ex, tok);
-                        },
-                        +[](void* v)
-                            -> io_result<std::size_t> {
-                            return static_cast<decayed*>(
-                                v)->await_resume();
-                        },
-                        +[](void* v) {
-                            delete static_cast<decayed*>(v);
-                        }};
+                    // BISECT: discard awaitable, return
+                    // suspend_always clone
+                    (void)a;
+                    return erased_io_awaiter{};
 #else
                     struct wrapper
                     {
@@ -402,20 +370,9 @@ class write_now
     op_type
     operator()(Buffers buffers)
     {
-        std::size_t const total_size = buffer_size(buffers);
-        std::size_t total_written = 0;
-        while(total_written < total_size)
-        {
-            auto r = co_await stream_.write_some(
-                detail::make_consumed(buffers, total_written));
-            if(r.ec)
-            {
-                io_result<std::size_t> result{r.ec, total_written};
-                co_return result;
-            }
-            total_written += r.t1;
-        }
-        io_result<std::size_t> result{{}, total_written};
+        // BISECT: co_await with custom suspend_always clone
+        co_await stream_.write_some(buffers);
+        io_result<std::size_t> result{{}, buffer_size(buffers)};
         co_return result;
     }
 #else