fix: make Task promise_type a non-aggregate to prevent Clang 21 SIGSEGV

lib/inc/drogon/utils/coroutine.h

@@ -196,6 +196,11 @@ struct [[nodiscard]] Task
 
     struct promise_type
     {
+        // Make promise_type a non-aggregate so Clang >= 21 does not
+        // aggregate-initialize `value` from the first coroutine argument
+        // (crashes if the conversion throws). See issue #2579.
+        promise_type() = default;
+
         Task<T> get_return_object()
         {
             return Task<T>{handle_type::from_promise(*this)};
@@ -300,6 +305,9 @@ struct [[nodiscard]] Task<void>
 
     struct promise_type
     {
+        // Same as Task<T>::promise_type above. See issue #2579.
+        promise_type() = default;
+
         Task<> get_return_object()
         {
             return Task<>{handle_type::from_promise(*this)};

lib/tests/unittests/CoroutineTest.cc

@@ -328,3 +328,27 @@ DROGON_TEST(WhenAll)
         CHECK(counter == 1);
     }(TEST_CTX);
 }
+
+DROGON_TEST(PromiseNotAggregateInitializedFromArgs)
+{
+    // Clang >= 21 used to aggregate-initialize Task<T>::promise_type::value
+    // from the first coroutine argument. If the argument was implicitly
+    // convertible to T and the conversion threw (e.g. nlohmann::json), the
+    // exception escaped the partially constructed coroutine frame and crashed
+    // the process. promise_type is a non-aggregate now, so the promise is
+    // default-constructed and the conversion never runs.
+    struct ThrowOnConvert
+    {
+        operator std::string() const
+        {
+            throw std::runtime_error("must not be converted");
+        }
+    };
+
+    auto returnOk = [](const ThrowOnConvert &) -> Task<std::string> {
+        co_return "ok";
+    };
+
+    ThrowOnConvert arg;
+    CHECK(sync_wait(returnOk(arg)) == "ok");
+}