passenger 6.0.16 → 6.0.17

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/coro_completion_handler.hpp

@@ -0,0 +1,171 @@
+//
+// experimental/detail/coro_completion_handler.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_COMPLETION_HANDLER_HPP
+#define BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_COMPLETION_HANDLER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/experimental/coro.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+namespace detail {
+
+template <typename Promise, typename... Args>
+struct coro_completion_handler
+{
+  coro_completion_handler(coroutine_handle<Promise> h,
+      std::optional<std::tuple<Args...>>& result)
+    : self(h),
+      result(result)
+  {
+  }
+
+  coro_completion_handler(coro_completion_handler&&) = default;
+
+  coroutine_handle<Promise> self;
+
+  std::optional<std::tuple<Args...>>& result;
+
+  using promise_type = Promise;
+
+  void operator()(Args... args)
+  {
+    result.emplace(std::move(args)...);
+    self.resume();
+  }
+
+  using allocator_type = typename promise_type::allocator_type;
+  allocator_type get_allocator() const noexcept
+  {
+    return self.promise().get_allocator();
+  }
+
+  using executor_type = typename promise_type::executor_type;
+  executor_type get_executor() const noexcept
+  {
+    return self.promise().get_executor();
+  }
+
+  using cancellation_slot_type = typename promise_type::cancellation_slot_type;
+  cancellation_slot_type get_cancellation_slot() const noexcept
+  {
+    return self.promise().get_cancellation_slot();
+  }
+};
+
+template <typename Signature>
+struct coro_completion_handler_type;
+
+template <typename... Args>
+struct coro_completion_handler_type<void(Args...)>
+{
+  using type = std::tuple<Args...>;
+
+  template <typename Promise>
+  using completion_handler = coro_completion_handler<Promise, Args...>;
+};
+
+template <typename Signature>
+using coro_completion_handler_type_t =
+  typename coro_completion_handler_type<Signature>::type;
+
+inline void coro_interpret_result(std::tuple<>&&)
+{
+}
+
+template <typename... Args>
+inline auto coro_interpret_result(std::tuple<Args...>&& args)
+{
+  return std::move(args);
+}
+
+template <typename... Args>
+auto coro_interpret_result(std::tuple<std::exception_ptr, Args...>&& args)
+{
+  if (std::get<0>(args))
+    std::rethrow_exception(std::get<0>(args));
+
+  return std::apply(
+      [](auto, auto&&... rest)
+      {
+        return std::make_tuple(std::move(rest)...);
+      });
+}
+
+template <typename... Args>
+auto coro_interpret_result(
+    std::tuple<boost::system::error_code, Args...>&& args)
+{
+  if (std::get<0>(args))
+    boost::asio::detail::throw_exception(
+        boost::system::system_error(std::get<0>(args)));
+
+  return std::apply(
+      [](auto, auto&&... rest)
+      {
+        return std::make_tuple(std::move(rest)...);
+      });
+}
+
+template <typename  Arg>
+inline auto coro_interpret_result(std::tuple<Arg>&& args)
+{
+  return std::get<0>(std::move(args));
+}
+
+template <typename Arg>
+auto coro_interpret_result(std::tuple<std::exception_ptr, Arg>&& args)
+{
+  if (std::get<0>(args))
+    std::rethrow_exception(std::get<0>(args));
+  return std::get<1>(std::move(args));
+}
+
+inline auto coro_interpret_result(
+    std::tuple<boost::system::error_code>&& args)
+{
+  if (std::get<0>(args))
+    boost::asio::detail::throw_exception(
+        boost::system::system_error(std::get<0>(args)));
+}
+
+inline auto coro_interpret_result(std::tuple<std::exception_ptr>&& args)
+{
+  if (std::get<0>(args))
+    std::rethrow_exception(std::get<0>(args));
+}
+
+template <typename Arg>
+auto coro_interpret_result(std::tuple<boost::system::error_code, Arg>&& args)
+{
+  if (std::get<0>(args))
+    boost::asio::detail::throw_exception(
+        boost::system::system_error(std::get<0>(args)));
+  return std::get<1>(std::move(args));
+}
+
+} // namespace detail
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_DETAIL_CORO_COMPLETION_HANDLER_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/coro_promise_allocator.hpp

@@ -20,95 +20,118 @@ namespace asio {
 namespace experimental {
 namespace detail {
 
-template <typename Coroutine,
-     typename Executor = typename Coroutine::executor_type,
-     typename Allocator = typename std::allocator_traits<
-       associated_allocator_t<Executor>>:: template rebind_alloc<std::byte>,
-     bool Noexcept = noexcept(std::declval<Allocator>().allocate(0u))>
-struct coro_promise_allocator
+/// Allocate the memory and put the allocator behind the coro memory
+template <typename AllocatorType>
+void* allocate_coroutine(const std::size_t size, AllocatorType alloc_)
 {
-  using allocator_type = Allocator;
+  using alloc_type = typename std::allocator_traits<AllocatorType>::template
+    rebind_alloc<unsigned char>;
+  alloc_type alloc{alloc_};
+
+  const auto align_needed = size % alignof(alloc_type);
+  const auto align_offset = align_needed != 0
+    ? alignof(alloc_type) - align_needed : 0ull;
+  const auto alloc_size = size + sizeof(alloc_type) + align_offset;
+  const auto raw =
+    std::allocator_traits<alloc_type>::allocate(alloc, alloc_size);
+  new(raw + size + align_offset) alloc_type(std::move(alloc));
+
+  return raw;
+}
+
+/// Deallocate the memory and destroy the allocator in the coro memory.
+template <typename AllocatorType>
+void deallocate_coroutine(void* raw_, const std::size_t size)
+{
+  using alloc_type = typename std::allocator_traits<AllocatorType>::template
+    rebind_alloc<unsigned char>;
 
-  template <typename... Args>
-  void* operator new(const std::size_t size, Executor executor, Args&&...)
-  {
-    static_assert(std::is_nothrow_move_constructible_v<allocator_type>);
-    allocator_type alloc{get_associated_allocator(executor)};
-
-    const auto csize = size + sizeof(alloc);
-    const auto raw =
-      std::allocator_traits<allocator_type>::allocate(alloc, csize);
-    new (raw) allocator_type(std::move(alloc));
-    return static_cast<std::byte*>(raw) + sizeof(alloc);
-  }
+  const auto raw = static_cast<unsigned char *>(raw_);
 
-  template <execution_context Context, typename... Args>
-  void* operator new(const std::size_t size, Context&& ctx, Args&&... args)
-  {
-    return coro_promise_allocator::operator new(size,
-        ctx.get_executor(), std::forward<Args>(args)...);
-  }
+  const auto align_needed = size % alignof(alloc_type);
+  const auto align_offset = align_needed != 0
+    ? alignof(alloc_type) - align_needed : 0ull;
+  const auto alloc_size = size + sizeof(alloc_type) + align_offset;
 
-  void operator delete(void* raw, std::size_t size )
-  {
-    auto * alloc_p = static_cast<allocator_type*>(raw);
+  auto alloc_p = reinterpret_cast<alloc_type *>(raw + size + align_offset);
+  auto alloc = std::move(*alloc_p);
+  alloc_p->~alloc_type();
+  std::allocator_traits<alloc_type>::deallocate(alloc, raw, alloc_size);
+}
+
+template <typename T>
+constexpr std::size_t variadic_first(std::size_t = 0u)
+{
+  return std::numeric_limits<std::size_t>::max();
+}
 
-    auto alloc = std::move(*alloc_p);
-    alloc_p->~allocator_type();
-    std::allocator_traits<allocator_type>::deallocate(alloc,
-        static_cast<std::byte*>(raw), size + sizeof(allocator_type));
-  }
-};
 
-template <typename Coroutine, typename Executor>
-struct coro_promise_allocator<Coroutine,
-    Executor, std::allocator<std::byte>, false>
+template <typename T, typename First, typename... Args>
+constexpr std::size_t variadic_first(std::size_t pos = 0u)
 {
+  if constexpr (std::is_same_v<std::decay_t<First>, T>)
+    return pos;
+  else
+    return variadic_first<T, Args...>(pos+1);
+}
+
+template <std::size_t Idx, typename First, typename... Args>
+  requires (Idx <= sizeof...(Args))
+constexpr decltype(auto) get_variadic(First&& first, Args&&... args)
+{
+  if constexpr (Idx == 0u)
+    return static_cast<First>(first);
+  else
+    return get_variadic<Idx-1u>(static_cast<Args>(args)...);
+}
 
-};
+template <std::size_t Idx>
+constexpr decltype(auto) get_variadic();
 
-template <typename Coroutine, typename Executor, typename Allocator>
-struct coro_promise_allocator<Coroutine, Executor, Allocator, true>
+template <typename Allocator>
+struct coro_promise_allocator
 {
   using allocator_type = Allocator;
+  allocator_type get_allocator() const {return alloc_;}
 
   template <typename... Args>
-  void* operator new(const std::size_t size,
-      Executor executor, Args&&...) noexcept
+  void* operator new(const std::size_t size, Args & ... args)
+  {
+    return allocate_coroutine(size,
+        get_variadic<variadic_first<std::allocator_arg_t,
+          std::decay_t<Args>...>() + 1u>(args...));
+  }
+
+  void operator delete(void* raw, const std::size_t size)
   {
-    static_assert(std::is_nothrow_move_constructible_v<allocator_type>);
-    allocator_type alloc{get_associated_allocator(executor)};
-
-    const auto csize = size + sizeof(alloc);
-    const auto raw =
-      std::allocator_traits<allocator_type>::allocate(alloc, csize);
-    if (raw == nullptr)
-      return nullptr;
-    new (raw) allocator_type(std::move(alloc));
-    return static_cast<std::byte*>(raw) + sizeof(alloc);
+    deallocate_coroutine<allocator_type>(raw, size);
   }
 
-  template <execution_context Context, typename... Args>
-  void* operator new(const std::size_t size,
-      Context&& ctx, Args&&... args) noexcept
+  template <typename... Args>
+  coro_promise_allocator(Args&& ... args)
+    : alloc_(
+        get_variadic<variadic_first<std::allocator_arg_t,
+          std::decay_t<Args>...>() + 1u>(args...))
   {
-    return coro_promise_allocator::operator new(size,
-        ctx.get_executor(), std::forward<Args>(args)...);
   }
 
-  void operator delete(void* raw, std::size_t size) noexcept
+private:
+  allocator_type alloc_;
+};
+
+template <>
+struct coro_promise_allocator<std::allocator<void>>
+{
+  using allocator_type = std::allocator<void>;
+
+  template <typename... Args>
+  coro_promise_allocator(Args&&...)
   {
-    auto * alloc_p = static_cast<allocator_type*>(raw);
-    auto alloc = std::move(*alloc_p);
-    alloc_p->~allocator_type();
-    const auto csize = size + sizeof(allocator_type);
-    std::allocator_traits<allocator_type>::deallocate(alloc,
-        static_cast<std::byte*>(raw) - sizeof(allocator_type), csize);
   }
 
-  static auto get_return_object_on_allocation_failure() noexcept -> Coroutine
+  allocator_type get_allocator() const
   {
-    return Coroutine{};
+    return {};
   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/asio/experimental/detail/partial_promise.hpp

@@ -13,6 +13,7 @@
 #define BOOST_ASIO_EXPERIMENTAL_DETAIL_PARTIAL_PROMISE_HPP
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/append.hpp>
 #include <boost/asio/awaitable.hpp>
 #include <boost/asio/experimental/coro_traits.hpp>
 
@@ -45,7 +46,33 @@ using std::experimental::noop_coroutine;
 
 #endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
 
-struct partial_promise
+struct partial_coro
+{
+  coroutine_handle<void> handle{nullptr};
+};
+
+template <typename Allocator>
+struct partial_promise_base
+{
+  template <typename Executor, typename Token, typename... Args>
+  void* operator new(const std::size_t size, Executor&, Token& tk, Args&...)
+  {
+    return allocate_coroutine<Allocator>(size, get_associated_allocator(tk));
+  }
+
+  void operator delete(void* raw, const std::size_t size)
+  {
+    deallocate_coroutine<Allocator>(raw, size);
+  }
+};
+
+template <>
+struct partial_promise_base<std::allocator<void>>
+{
+};
+
+template <typename Allocator>
+struct partial_promise : partial_promise_base<Allocator>
 {
   auto initial_suspend() noexcept
   {
@@ -62,7 +89,7 @@ struct partial_promise
 
       auto await_suspend(boost::asio::detail::coroutine_handle<>) noexcept
       {
-        p->get_return_object().destroy();
+        p->get_return_object().handle.destroy();
       }
 
       constexpr void await_resume() noexcept {}
@@ -73,9 +100,9 @@ struct partial_promise
 
   void return_void() {}
 
-  coroutine_handle<partial_promise> get_return_object()
+  partial_coro get_return_object()
   {
-    return coroutine_handle<partial_promise>::from_promise(*this);
+    return partial_coro{coroutine_handle<partial_promise>::from_promise(*this)};
   }
 
   void unhandled_exception()
@@ -84,7 +111,9 @@ struct partial_promise
   }
 };
 
-} // namespace detail
+
+
+}; // namespace detail
 } // namespace experimental
 } // namespace asio
 } // namespace boost
@@ -93,12 +122,14 @@ struct partial_promise
 
 namespace std {
 
-template <typename ... Args>
+template <typename Executor, typename Completion, typename... Args>
 struct coroutine_traits<
-    coroutine_handle<boost::asio::experimental::detail::partial_promise>,
-    Args...>
+    boost::asio::experimental::detail::partial_coro,
+    Executor, Completion, Args...>
 {
-  using promise_type = boost::asio::experimental::detail::partial_promise;
+  using promise_type =
+    boost::asio::experimental::detail::partial_promise<
+      boost::asio::associated_allocator_t<Completion>>;
 };
 
 } // namespace std
@@ -107,12 +138,14 @@ struct coroutine_traits<
 
 namespace std { namespace experimental {
 
-template <typename... Args>
+template <typename Executor, typename Completion, typename... Args>
 struct coroutine_traits<
-    coroutine_handle<boost::asio::experimental::detail::partial_promise>,
-    Args...>
+    boost::asio::experimental::detail::partial_coro,
+    Executor, Completion, Args...>
 {
-  using promise_type = boost::asio::experimental::detail::partial_promise;
+  using promise_type =
+    boost::asio::experimental::detail::partial_promise<
+      boost::asio::associated_allocator_t<Completion>>;
 };
 
 }} // namespace std::experimental
@@ -124,51 +157,39 @@ namespace asio {
 namespace experimental {
 namespace detail {
 
-template <typename CompletionToken>
-auto post_coroutine(CompletionToken token) noexcept
-  -> coroutine_handle<partial_promise>
-{
-  post(std::move(token));
-  co_return;
-}
-
-template <execution::executor Executor, typename CompletionToken>
-auto post_coroutine(Executor exec, CompletionToken token) noexcept
-  -> coroutine_handle<partial_promise>
-{
-  post(exec, std::move(token));
-  co_return;
-}
-
-template <detail::execution_context Context, typename CompletionToken>
-auto post_coroutine(Context &ctx, CompletionToken token) noexcept
-  -> coroutine_handle<partial_promise>
+template <execution::executor Executor,
+    typename CompletionToken, typename... Args>
+partial_coro post_coroutine(Executor exec,
+    CompletionToken token, Args&&... args) noexcept
 {
-  post(ctx, std::move(token));
+  post(exec, boost::asio::append(std::move(token), std::move(args)...));
   co_return;
 }
 
-template <typename CompletionToken>
-auto dispatch_coroutine(CompletionToken token) noexcept
-  -> coroutine_handle<partial_promise>
+template <detail::execution_context Context,
+    typename CompletionToken, typename... Args>
+partial_coro post_coroutine(Context& ctx,
+    CompletionToken token, Args&&... args) noexcept
 {
-  dispatch(std::move(token));
+  post(ctx, boost::asio::append(std::move(token), std::move(args)...));
   co_return;
 }
 
-template <execution::executor Executor, typename CompletionToken>
-auto dispatch_coroutine(Executor exec, CompletionToken token) noexcept
-  -> coroutine_handle<partial_promise>
+template <execution::executor Executor,
+    typename CompletionToken, typename... Args>
+partial_coro dispatch_coroutine(Executor exec,
+    CompletionToken token, Args&&... args) noexcept
 {
-  dispatch(exec, std::move(token));
+  dispatch(exec, boost::asio::append(std::move(token), std::move(args)...));
   co_return;
 }
 
-template <detail::execution_context Context, typename CompletionToken>
-auto dispatch_coroutine(Context &ctx, CompletionToken token) noexcept
-  -> coroutine_handle<partial_promise>
+template <detail::execution_context Context,
+    typename CompletionToken, typename... Args>
+partial_coro dispatch_coroutine(Context& ctx,
+    CompletionToken token, Args &&... args) noexcept
 {
-  dispatch(ctx, std::move(token));
+  dispatch(ctx, boost::asio::append(std::move(token), std::move(args)...));
   co_return;
 }
 

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

@@ -213,9 +213,19 @@ struct associator<Associator,
     experimental::detail::as_single_handler<Handler>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const experimental::detail::as_single_handler<Handler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const experimental::detail::as_single_handler<Handler>& h)
+    BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<Handler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<Handler, DefaultCandidate>::type)
+  get(const experimental::detail::as_single_handler<Handler>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }