coro::task_container gc fix not completing coroutines

The coro::task_container::gc_internal function was deleting coroutines
when marked as .done(), however there is some mechanism that rarely
would cause the user_task coroutine to not actually execute. I'm still
not sure exactly why this is the case but:

1) Simply disabling gc_internal() would stop the problem
2) Running gc_internal() and moving the coro::task to a 'dead' list
   still caused the issue.

With these in mind I spent time re-reading the specification on the
final_suspend and determined that coro::task_container should be a thing
atomic counter to track the submitted coroutines and have them self
delete. The self deletion is now done via a
coro::detail::task_self_destroying coroutine type that takes advantage
of the promise's final_suspend() not suspending. The spec states that if
this doesn't suspend then the coroutine will call destroy() on itself.

Closes #287

Author: jbaldwin

CMakeLists.txt

@@ -76,6 +76,7 @@ set(LIBCORO_SOURCE_FILES
     include/coro/concepts/promise.hpp
     include/coro/concepts/range_of.hpp
 
+    include/coro/detail/task_self_destroying.hpp / src/detail/task_self_destroying.cpp
     include/coro/detail/void_value.hpp
 
     include/coro/attribute.hpp

examples/coro_task_container.cpp

@@ -55,7 +55,7 @@ int main()
         tc.start(serve_client(std::move(client)));
 
         // Wait for all clients to complete before shutting down the tcp::server.
-        co_await tc.garbage_collect_and_yield_until_empty();
+        co_await tc.yield_until_empty();
         co_return;
     };
 

include/coro/detail/task_self_destroying.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <atomic>
+#include <coroutine>
+#include <cstdint>
+
+namespace coro::detail
+{
+
+class task_self_destroying;
+
+class promise_self_destroying
+{
+public:
+    promise_self_destroying();
+    ~promise_self_destroying();
+
+    promise_self_destroying(const promise_self_destroying&) = delete;
+    promise_self_destroying(promise_self_destroying&&);
+    auto operator=(const promise_self_destroying&) -> promise_self_destroying& = delete;
+    auto operator=(promise_self_destroying&&) -> promise_self_destroying&;
+
+    auto get_return_object() -> task_self_destroying;
+    auto initial_suspend() -> std::suspend_always;
+    auto final_suspend() noexcept -> std::suspend_never;
+    auto return_void() noexcept -> void;
+    auto unhandled_exception() -> void;
+
+    auto task_container_size(std::atomic<std::size_t>& task_container_size) -> void;
+    /**
+     * The coro::task_container<executor_t> m_size member to decrement upon the coroutine completing.
+     */
+private:
+    std::atomic<std::size_t>* m_task_container_size{nullptr};
+};
+
+/**
+ * This task will self delete upon completing. This is useful for usecase that the lifetime of the
+ * coroutine cannot be determined and it needs to 'self' delete. This is achieved by returning
+ * std::suspend_never from the promise::final_suspend which then based on the spec tells the
+ * coroutine to destroy itself. This means any classes that use this task cannot have owning
+ * pointers or relationships to this class and must not use it past its completion.
+ *
+ * This class is currently only used by coro::task_container<executor_t> and will decrement its
+ * m_size internal count when the coroutine completes.
+ */
+class task_self_destroying
+{
+public:
+    using promise_type = promise_self_destroying;
+
+    explicit task_self_destroying(promise_self_destroying& promise);
+    ~task_self_destroying();
+
+    task_self_destroying(const task_self_destroying&) = delete;
+    task_self_destroying(task_self_destroying&&);
+    auto operator=(const task_self_destroying&) -> task_self_destroying& = delete;
+    auto operator=(task_self_destroying&&) -> task_self_destroying&;
+
+    auto promise() -> promise_self_destroying& { return *m_promise; }
+    auto handle() -> std::coroutine_handle<promise_self_destroying> { return std::coroutine_handle<promise_self_destroying>::from_promise(*m_promise); }
+private:
+    promise_self_destroying* m_promise{nullptr};
+};
+
+} // namespace coro::detail

include/coro/io_scheduler.hpp

@@ -178,7 +178,7 @@ class io_scheduler : public std::enable_shared_from_this<io_scheduler>
      * @param task The task to execute on this io_scheduler.  It's lifetime ownership will be transferred
      *             to this io_scheduler.
      */
-    auto schedule(coro::task<void>&& task) -> void;
+    auto schedule(coro::task<void>&& task) -> bool;
 
     /**
      * Schedules the current task to run after the given amount of time has elapsed.
@@ -247,7 +247,7 @@ class io_scheduler : public std::enable_shared_from_this<io_scheduler>
      */
     auto resume(std::coroutine_handle<> handle) -> bool
     {
-        if (handle == nullptr)
+        if (handle == nullptr || handle.done())
         {
             return false;
         }
@@ -259,6 +259,7 @@ class io_scheduler : public std::enable_shared_from_this<io_scheduler>
 
         if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)
         {
+            m_size.fetch_add(1, std::memory_order::release);
             {
                 std::scoped_lock lk{m_scheduled_tasks_mutex};
                 m_scheduled_tasks.emplace_back(handle);
@@ -309,13 +310,6 @@ class io_scheduler : public std::enable_shared_from_this<io_scheduler>
      */
     auto shutdown() noexcept -> void;
 
-    /**
-     * Scans for completed coroutines and destroys them freeing up resources.  This is also done on starting
-     * new tasks but this allows the user to cleanup resources manually.  One usage might be making sure fds
-     * are cleaned up as soon as possible.
-     */
-    auto garbage_collect() noexcept -> void;
-
 private:
     /// The configuration options.
     options m_opts;