[FOLD]

Author: vinniefalco

include/boost/capy/io/write_now.hpp

@@ -114,32 +114,64 @@ class write_now
             std::stop_token token_;
             bool done_ = false;
 
-            // GCC 14 ICEs when non-trivial types live in
-            // coroutine frames; keep this wrapper trivial.
-            template<class Inner>
-            struct io_await_wrapper
+            // GCC 14 ICEs on any template type instantiated
+            // with an IoAwaitable in the coroutine frame, even
+            // trivial ones. Type-erase behind function pointers
+            // so the frame sees only a non-template struct.
+            struct erased_io_awaiter
             {
-                Inner* inner_;
+                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()
                 {
-                    return inner_->await_ready();
+                    return ready_(inner_);
                 }
 
                 coro await_suspend(coro h)
                 {
-                    return detail::call_await_suspend(
+                    return suspend_(
                         inner_, h,
                         p_->ex_, p_->token_);
                 }
 
-                decltype(auto) await_resume()
+                io_result<std::size_t> await_resume()
                 {
-                    auto r = inner_->await_resume();
-                    delete inner_;
+                    auto r = resume_(inner_);
+                    destroy_(inner_);
+                    inner_ = nullptr;
                     return r;
                 }
+
+                ~erased_io_awaiter()
+                {
+                    if(inner_)
+                        destroy_(inner_);
+                }
+
+                erased_io_awaiter(
+                    erased_io_awaiter&& o) noexcept
+                    : inner_(std::exchange(o.inner_, nullptr))
+                    , p_(o.p_)
+                    , ready_(o.ready_)
+                    , suspend_(o.suspend_)
+                    , resume_(o.resume_)
+                    , destroy_(o.destroy_)
+                {
+                }
+
+                erased_io_awaiter(
+                    erased_io_awaiter const&) = delete;
+                erased_io_awaiter& operator=(
+                    erased_io_awaiter const&) = delete;
+                erased_io_awaiter& operator=(
+                    erased_io_awaiter&&) = delete;
             };
 
             op_type get_return_object()
@@ -207,9 +239,28 @@ class write_now
                 if constexpr (IoAwaitable<decayed>)
                 {
 #if BOOST_CAPY_WRITE_NOW_WORKAROUND
-                    return io_await_wrapper<decayed>{
+                    return erased_io_awaiter{
                         new decayed(std::forward<A>(a)),
-                        this};
+                        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);
+                        }};
 #else
                     struct wrapper
                     {