passenger 6.0.16 → 6.0.18

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/impl/coro.hpp

@@ -17,14 +17,19 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-
+#include <boost/asio/append.hpp>
+#include <boost/asio/associated_cancellation_slot.hpp>
+#include <boost/asio/bind_allocator.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/experimental/detail/coro_completion_handler.hpp>
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace experimental {
 
-template <typename Yield, typename Return, typename Executor>
+template <typename Yield, typename Return,
+    typename Executor, typename Allocator>
 struct coro;
 
 namespace detail {
@@ -66,7 +71,8 @@ struct coro_cancellation_source
   }
 };
 
-template <typename Signature, typename Return, typename Executor>
+template <typename Signature, typename Return,
+    typename Executor, typename Allocator>
 struct coro_promise;
 
 template <typename T>
@@ -160,13 +166,13 @@ struct coro_with_arg
 
     constexpr static bool await_ready() { return false; }
 
-    template <typename Y, typename R, typename E>
-    auto await_suspend(coroutine_handle<coro_promise<Y, R, E>> h)
+    template <typename Y, typename R, typename E, typename A>
+    auto await_suspend(coroutine_handle<coro_promise<Y, R, E, A>> h)
       -> coroutine_handle<>
     {
       auto& hp = h.promise();
 
-      if constexpr (!coro_promise<Y, R, E>::is_noexcept)
+      if constexpr (!coro_promise<Y, R, E, A>::is_noexcept)
       {
         if ((hp.cancel->state.cancelled() != cancellation_type::none)
             && hp.cancel->throw_if_cancelled_)
@@ -190,7 +196,7 @@ struct coro_with_arg
           dispatch_coroutine(
               boost::asio::prefer(hp.get_executor(),
                 execution::outstanding_work.tracked),
-                [h]() mutable { h.resume(); });
+                [h]() mutable { h.resume(); }).handle;
 
         coro.coro_->reset_error();
         coro.coro_->input_ = std::move(value);
@@ -231,7 +237,7 @@ struct coro_with_arg
           typename coro_t::promise_type>::from_promise(*coro.coro_);
 
         return dispatch_coroutine(
-            coro.coro_->get_executor(), [hh]() mutable { hh.resume(); });
+            coro.coro_->get_executor(), [hh]() mutable { hh.resume(); }).handle;
       }
     }
 
@@ -567,9 +573,10 @@ struct coro_promise_exchange<Yield, void, void> : coro_awaited_from
   }
 };
 
-template <typename Yield, typename Return, typename Executor>
+template <typename Yield, typename Return,
+    typename Executor, typename Allocator>
 struct coro_promise final :
-  coro_promise_allocator<coro<Yield, Return, Executor>>,
+  coro_promise_allocator<Allocator>,
   coro_promise_error<coro_traits<Yield, Return, Executor>::is_noexcept>,
   coro_promise_exchange<
       typename coro_traits<Yield, Return, Executor>::yield_type,
@@ -590,6 +597,13 @@ struct coro_promise final :
   std::optional<coro_cancellation_source> cancel_source;
   coro_cancellation_source * cancel;
 
+  using cancellation_slot_type = boost::asio::cancellation_slot;
+
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return cancel ? cancel->slot : cancellation_slot_type{};
+  }
+
   using allocator_type =
     typename std::allocator_traits<associated_allocator_t<Executor>>::
       template rebind_alloc<std::byte>;
@@ -613,32 +627,40 @@ struct coro_promise final :
   }
 
   template <typename... Args>
-  coro_promise(Executor executor, Args&&...) noexcept
-    : executor_(std::move(executor))
+  coro_promise(Executor executor, Args&&... args) noexcept
+    : coro_promise_allocator<Allocator>(
+        executor, std::forward<Args>(args)...),
+      executor_(std::move(executor))
   {
   }
 
   template <typename First, typename... Args>
-  coro_promise(First&&, Executor executor, Args&&...) noexcept
-    : executor_(std::move(executor))
+  coro_promise(First&& f, Executor executor, Args&&... args) noexcept
+    : coro_promise_allocator<Allocator>(
+        f, executor, std::forward<Args>(args)...),
+      executor_(std::move(executor))
   {
   }
 
   template <typename First, detail::execution_context Context, typename... Args>
-  coro_promise(First&&, Context&& ctx, Args&&...) noexcept
-    : executor_(ctx.get_executor())
+  coro_promise(First&& f, Context&& ctx, Args&&... args) noexcept
+    : coro_promise_allocator<Allocator>(
+        f, ctx, std::forward<Args>(args)...),
+      executor_(ctx.get_executor())
   {
   }
 
   template <detail::execution_context Context, typename... Args>
-  coro_promise(Context&& ctx, Args&&...) noexcept
-    : executor_(ctx.get_executor())
+  coro_promise(Context&& ctx, Args&&... args) noexcept
+    : coro_promise_allocator<Allocator>(
+        ctx, std::forward<Args>(args)...),
+      executor_(ctx.get_executor())
   {
   }
 
   auto get_return_object()
   {
-    return coro<Yield, Return, Executor>{this};
+    return coro<Yield, Return, Executor, Allocator>{this};
   }
 
   auto initial_suspend() noexcept
@@ -862,48 +884,81 @@ struct coro_promise final :
   }
 
   template <typename T_>
-    requires requires(T_ t) {{ t.async_wait(use_coro) }; }
+    requires requires(T_ t) {{ t.async_wait(deferred) }; }
   auto await_transform(T_& t) -> decltype(auto)
   {
-    return await_transform(t.async_wait(use_coro));
+    return await_transform(t.async_wait(deferred));
   }
 
-  template <typename... Ts>
-  auto await_transform(coro_init_handler<Executor, Ts...>&& kr) const
+  template <typename Op>
+  auto await_transform(Op&& op,
+      typename constraint<is_async_operation<Op>::value>::type = 0)
   {
-    assert(cancel);
-    if constexpr (is_noexcept)
-      return std::move(kr).as_noexcept(cancel->state.slot());
-    else
+    if ((cancel->state.cancelled() != cancellation_type::none)
+        && cancel->throw_if_cancelled_)
     {
-      if ((cancel->state.cancelled() != cancellation_type::none)
-          && cancel->throw_if_cancelled_)
+      boost::asio::detail::throw_error(
+          boost::asio::error::operation_aborted, "coro-cancelled");
+    }
+    using signature = typename completion_signature_of<Op>::type;
+    using result_type = detail::coro_completion_handler_type_t<signature>;
+    using handler_type =
+      typename detail::coro_completion_handler_type<signature>::template
+        completion_handler<coro_promise>;
+
+    struct aw_t
+    {
+      Op op;
+      std::optional<result_type> result;
+
+      constexpr static bool await_ready()
       {
-        boost::asio::detail::throw_error(
-            boost::asio::error::operation_aborted, "coro-cancelled");
+        return false;
       }
-      return std::move(kr).as_throwing(cancel->state.slot());
-    }
+
+      void await_suspend(coroutine_handle<coro_promise> h)
+      {
+        std::move(op)(handler_type{h, result});
+      }
+
+      auto await_resume()
+      {
+        if constexpr (is_noexcept)
+        {
+          if constexpr (std::tuple_size_v<result_type> == 0u)
+            return;
+          else if constexpr (std::tuple_size_v<result_type> == 1u)
+            return std::get<0>(std::move(result).value());
+          else
+            return std::move(result).value();
+        }
+        else
+          return detail::coro_interpret_result(std::move(result).value());
+      }
+    };
+
+    return aw_t{std::move(op), {}};
   }
 };
 
 } // namespace detail
 
-template <typename Yield, typename Return, typename Executor>
-struct coro<Yield, Return, Executor>::awaitable_t
+template <typename Yield, typename Return,
+    typename Executor, typename Allocator>
+struct coro<Yield, Return, Executor, Allocator>::awaitable_t
 {
   coro& coro_;
 
   constexpr static bool await_ready() { return false; }
 
-  template <typename Y, typename R, typename E>
+  template <typename Y, typename R, typename E, typename A>
   auto await_suspend(
-      detail::coroutine_handle<detail::coro_promise<Y, R, E>> h)
+      detail::coroutine_handle<detail::coro_promise<Y, R, E, A>> h)
     -> detail::coroutine_handle<>
   {
     auto& hp = h.promise();
 
-    if constexpr (!detail::coro_promise<Y, R, E>::is_noexcept)
+    if constexpr (!detail::coro_promise<Y, R, E, A>::is_noexcept)
     {
       if ((hp.cancel->state.cancelled() != cancellation_type::none)
           && hp.cancel->throw_if_cancelled_)
@@ -929,7 +984,7 @@ struct coro<Yield, Return, Executor>::awaitable_t
           [h]() mutable
           {
             h.resume();
-          });
+          }).handle;
 
       coro_.coro_->reset_error();
 
@@ -966,12 +1021,12 @@ struct coro<Yield, Return, Executor>::awaitable_t
       }
 
       auto hh = detail::coroutine_handle<
-        detail::coro_promise<Yield, Return, Executor>>::from_promise(
+        detail::coro_promise<Yield, Return, Executor, Allocator>>::from_promise(
             *coro_.coro_);
 
       return detail::dispatch_coroutine(
           coro_.coro_->get_executor(),
-          [hh]() mutable { hh.resume(); });
+          [hh]() mutable { hh.resume(); }).handle;
     }
   }
 
@@ -984,10 +1039,13 @@ struct coro<Yield, Return, Executor>::awaitable_t
   }
 };
 
-template <typename Yield, typename Return, typename Executor>
-struct coro<Yield, Return, Executor>::initiate_async_resume
+template <typename Yield, typename Return,
+    typename Executor, typename Allocator>
+struct coro<Yield, Return, Executor, Allocator>::initiate_async_resume
 {
   typedef Executor executor_type;
+  typedef Allocator allocator_type;
+  typedef boost::asio::cancellation_slot cancellation_slot_type;
 
   explicit initiate_async_resume(coro* self)
     : coro_(self->coro_)
@@ -999,6 +1057,11 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
     return coro_->get_executor();
   }
 
+  allocator_type get_allocator() const noexcept
+  {
+    return coro_->get_allocator();
+  }
+
   template <typename E, typename WaitHandler>
   auto handle(E exec, WaitHandler&& handler,
       std::true_type /* error is noexcept */,
@@ -1034,11 +1097,8 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
       assert(ch && !ch.done());
 
-      coro->awaited_from = detail::post_coroutine(exec,
-          [coro, h = std::move(h)]() mutable
-          {
-            std::move(h)(std::move(coro->result_));
-          });
+      coro->awaited_from = detail::post_coroutine(
+          exec, std::move(h), coro->result_).handle;
       coro->reset_error();
       ch.resume();
     };
@@ -1054,40 +1114,23 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
         exec = std::move(exec)]() mutable
     {
       if (!coro)
-      {
-        boost::asio::post(exec,
-            [h = std::move(h)]() mutable
-            {
-              h(detail::coro_error<error_type>::invalid());
-            });
-        return;
-      }
+        return boost::asio::post(exec,
+            boost::asio::append(std::move(h),
+              detail::coro_error<error_type>::invalid()));
 
       auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
       if (!ch)
-      {
-        boost::asio::post(exec,
-            [h = std::move(h)]() mutable
-            {
-              h(detail::coro_error<error_type>::invalid());
-            });
-      }
+        return boost::asio::post(exec,
+            boost::asio::append(std::move(h),
+              detail::coro_error<error_type>::invalid()));
       else if (ch.done())
-      {
-        boost::asio::post(exec,
-            [h = std::move(h)]() mutable
-            {
-              h(detail::coro_error<error_type>::done());
-            });
-      }
+        return boost::asio::post(exec,
+            boost::asio::append(std::move(h),
+              detail::coro_error<error_type>::done()));
       else
       {
-        coro->awaited_from =
-          detail::post_coroutine(exec,
-              [coro, h = std::move(h)]() mutable
-              {
-                std::move(h)(std::move(coro->error_));
-              });
+        coro->awaited_from = detail::post_coroutine(
+            exec, std::move(h), coro->error_).handle;
         coro->reset_error();
         ch.resume();
       }
@@ -1104,43 +1147,24 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
         exec = std::move(exec)]() mutable
     {
       if (!coro)
-      {
-        boost::asio::post(exec,
-            [h = std::move(h)]() mutable
-            {
-              h(detail::coro_error<error_type>::invalid(), result_type{});
-            });
-        return;
-      }
+        return boost::asio::post(exec,
+            boost::asio::append(std::move(h),
+              detail::coro_error<error_type>::invalid(), result_type{}));
 
       auto ch =
         detail::coroutine_handle<promise_type>::from_promise(*coro);
       if (!ch)
-      {
-        boost::asio::post(exec,
-            [h = std::move(h)]() mutable
-            {
-              h(detail::coro_error<error_type>::invalid(), result_type{});
-            });
-      }
+        return boost::asio::post(exec,
+            boost::asio::append(std::move(h),
+              detail::coro_error<error_type>::invalid(), result_type{}));
       else if (ch.done())
-      {
-        boost::asio::post(exec,
-            [h = std::move(h)]() mutable
-            {
-              h(detail::coro_error<error_type>::done(), result_type{});
-            });
-      }
+        return boost::asio::post(exec,
+            boost::asio::append(std::move(h),
+              detail::coro_error<error_type>::done(), result_type{}));
       else
       {
-        coro->awaited_from =
-          detail::post_coroutine(exec,
-              [h = std::move(h), coro]() mutable
-              {
-                std::move(h)(
-                    std::move(coro->error_),
-                    std::move(coro->result_));
-              });
+        coro->awaited_from = detail::post_coroutine(
+            exec, std::move(h), coro->error_, coro->result_).handle;
         coro->reset_error();
         ch.resume();
       }