passenger 6.0.16 → 6.0.18

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

@@ -0,0 +1,113 @@
+//
+// experimental/use_promise.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 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_USE_PROMISE_HPP
+#define BOOST_ASIO_EXPERIMENTAL_USE_PROMISE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <memory>
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace experimental {
+
+template <typename Allocator = std::allocator<void>>
+struct use_promise_t
+{
+  /// The allocator type. The allocator is used when constructing the
+  /// @c promise object for a given asynchronous operation.
+  typedef Allocator allocator_type;
+
+  /// Construct using default-constructed allocator.
+  BOOST_ASIO_CONSTEXPR use_promise_t()
+  {
+  }
+
+  /// Construct using specified allocator.
+  explicit use_promise_t(const Allocator& allocator)
+    : allocator_(allocator)
+  {
+  }
+
+  /// Obtain allocator.
+  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  {
+    return allocator_;
+  }
+
+  /// Adapts an executor to add the @c use_promise_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c use_promise_t as the default completion token type.
+    typedef use_promise_t<Allocator> default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    executor_with_default(const InnerExecutor& ex) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+
+    /// Convert the specified executor to the inner executor type, then use
+    /// that to construct the adapted executor.
+    template <typename OtherExecutor>
+    executor_with_default(const OtherExecutor& ex,
+        typename constraint<
+          is_convertible<OtherExecutor, InnerExecutor>::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Function helper to adapt an I/O object to use @c use_promise_t as its
+  /// default completion token type.
+  template <typename T>
+  static typename decay<T>::type::template rebind_executor<
+      executor_with_default<typename decay<T>::type::executor_type>
+    >::other
+  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  {
+    return typename decay<T>::type::template rebind_executor<
+        executor_with_default<typename decay<T>::type::executor_type>
+      >::other(BOOST_ASIO_MOVE_CAST(T)(object));
+  }
+
+  /// Specify an alternate allocator.
+  template <typename OtherAllocator>
+  use_promise_t<OtherAllocator> rebind(const OtherAllocator& allocator) const
+  {
+    return use_promise_t<OtherAllocator>(allocator);
+  }
+
+private:
+  Allocator allocator_;
+};
+
+constexpr use_promise_t<> use_promise;
+
+} // namespace experimental
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/experimental/impl/use_promise.hpp>
+
+#endif // BOOST_ASIO_EXPERIMENTAL_USE_CORO_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/any_completion_executor.ipp

@@ -0,0 +1,132 @@
+//
+// impl/any_completion_executor.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_IMPL_ANY_COMPLETION_EXECUTOR_IPP
+#define BOOST_ASIO_IMPL_ANY_COMPLETION_EXECUTOR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#include <boost/asio/any_completion_executor.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+any_completion_executor::any_completion_executor() BOOST_ASIO_NOEXCEPT
+  : base_type()
+{
+}
+
+any_completion_executor::any_completion_executor(nullptr_t) BOOST_ASIO_NOEXCEPT
+  : base_type(nullptr_t())
+{
+}
+
+any_completion_executor::any_completion_executor(
+    const any_completion_executor& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<const base_type&>(e))
+{
+}
+
+any_completion_executor::any_completion_executor(std::nothrow_t,
+    const any_completion_executor& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<const base_type&>(e))
+{
+}
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+any_completion_executor::any_completion_executor(
+    any_completion_executor&& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<base_type&&>(e))
+{
+}
+
+any_completion_executor::any_completion_executor(std::nothrow_t,
+    any_completion_executor&& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<base_type&&>(e))
+{
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+any_completion_executor& any_completion_executor::operator=(
+    const any_completion_executor& e) BOOST_ASIO_NOEXCEPT
+{
+  base_type::operator=(static_cast<const base_type&>(e));
+  return *this;
+}
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+any_completion_executor& any_completion_executor::operator=(
+    any_completion_executor&& e) BOOST_ASIO_NOEXCEPT
+{
+  base_type::operator=(static_cast<base_type&&>(e));
+  return *this;
+}
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+any_completion_executor& any_completion_executor::operator=(nullptr_t)
+{
+  base_type::operator=(nullptr_t());
+  return *this;
+}
+
+any_completion_executor::~any_completion_executor()
+{
+}
+
+void any_completion_executor::swap(
+    any_completion_executor& other) BOOST_ASIO_NOEXCEPT
+{
+  static_cast<base_type&>(*this).swap(static_cast<base_type&>(other));
+}
+
+template <>
+any_completion_executor any_completion_executor::prefer(
+    const execution::outstanding_work_t::tracked_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_completion_executor any_completion_executor::prefer(
+    const execution::outstanding_work_t::untracked_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_completion_executor any_completion_executor::prefer(
+    const execution::relationship_t::fork_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+template <>
+any_completion_executor any_completion_executor::prefer(
+    const execution::relationship_t::continuation_t& p, int) const
+{
+  return static_cast<const base_type&>(*this).prefer(p);
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // !defined(BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
+
+#endif // BOOST_ASIO_IMPL_ANY_COMPLETION_EXECUTOR_IPP

data/src/cxx_supportlib/vendor-modified/boost/asio/impl/any_io_executor.ipp

@@ -41,11 +41,23 @@ any_io_executor::any_io_executor(const any_io_executor& e) BOOST_ASIO_NOEXCEPT
 {
 }
 
+any_io_executor::any_io_executor(std::nothrow_t,
+    const any_io_executor& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<const base_type&>(e))
+{
+}
+
 #if defined(BOOST_ASIO_HAS_MOVE)
 any_io_executor::any_io_executor(any_io_executor&& e) BOOST_ASIO_NOEXCEPT
   : base_type(static_cast<base_type&&>(e))
 {
 }
+
+any_io_executor::any_io_executor(std::nothrow_t,
+    any_io_executor&& e) BOOST_ASIO_NOEXCEPT
+  : base_type(static_cast<base_type&&>(e))
+{
+}
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
 any_io_executor& any_io_executor::operator=(

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

@@ -200,9 +200,18 @@ struct associator<Associator,
     detail::append_handler<Handler, Values...>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::append_handler<Handler, Values...>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::append_handler<Handler, Values...>& 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 detail::append_handler<Handler, Values...>& 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);
   }

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

@@ -228,9 +228,18 @@ struct associator<Associator,
     detail::as_tuple_handler<Handler>, DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type get(
-      const detail::as_tuple_handler<Handler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type
+  get(const detail::as_tuple_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 detail::as_tuple_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);
   }

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

@@ -209,9 +209,18 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<ReadHandler, DefaultCandidate>
 {
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::buffered_fill_handler<ReadHandler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<ReadHandler, DefaultCandidate>::type
+  get(const detail::buffered_fill_handler<ReadHandler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<ReadHandler, DefaultCandidate>::type)
+  get(const detail::buffered_fill_handler<ReadHandler>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -449,10 +458,20 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<ReadHandler, DefaultCandidate>
 {
-  static typename Associator<ReadHandler, DefaultCandidate>::type get(
-      const detail::buffered_read_some_handler<
+  static typename Associator<ReadHandler, DefaultCandidate>::type
+  get(const detail::buffered_read_some_handler<
+        MutableBufferSequence, ReadHandler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<ReadHandler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<ReadHandler, DefaultCandidate>::type)
+  get(const detail::buffered_read_some_handler<
         MutableBufferSequence, ReadHandler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<ReadHandler, DefaultCandidate>::get(h.handler_, c);
   }

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

@@ -189,9 +189,18 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<WriteHandler, DefaultCandidate>
 {
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::buffered_flush_handler<WriteHandler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+  static typename Associator<WriteHandler, DefaultCandidate>::type
+  get(const detail::buffered_flush_handler<WriteHandler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<WriteHandler, DefaultCandidate>::type)
+  get(const detail::buffered_flush_handler<WriteHandler>& h,
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -435,10 +444,20 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<WriteHandler, DefaultCandidate>
 {
-  static typename Associator<WriteHandler, DefaultCandidate>::type get(
-      const detail::buffered_write_some_handler<
+  static typename Associator<WriteHandler, DefaultCandidate>::type
+  get(const detail::buffered_write_some_handler<
+        ConstBufferSequence, WriteHandler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<WriteHandler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<WriteHandler, DefaultCandidate>::type)
+  get(const detail::buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c)))
   {
     return Associator<WriteHandler, DefaultCandidate>::get(h.handler_, c);
   }

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

@@ -97,23 +97,20 @@ awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
 
     done = true;
 
-    if (co_await awaitable_thread_has_context_switched{})
+    bool switched = (co_await awaitable_thread_has_context_switched{});
+    if (!switched)
     {
-      (dispatch)(handler_work.get_executor(),
-          [handler = std::move(handler), t = std::move(t)]() mutable
-          {
-            std::move(handler)(std::exception_ptr(), std::move(t));
-          });
-    }
-    else
-    {
-      (post)(handler_work.get_executor(),
-          [handler = std::move(handler), t = std::move(t)]() mutable
-          {
-            std::move(handler)(std::exception_ptr(), std::move(t));
-          });
+      (void) co_await (post)(
+          use_awaitable_t<Executor>{__FILE__,
+            __LINE__, "co_spawn_entry_point"});
     }
 
+    (dispatch)(handler_work.get_executor(),
+        [handler = std::move(handler), t = std::move(t)]() mutable
+        {
+          std::move(handler)(std::exception_ptr(), std::move(t));
+        });
+
     co_return;
   }
   catch (...)
@@ -124,22 +121,18 @@ awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
     e = std::current_exception();
   }
 
-  if (co_await awaitable_thread_has_context_switched{})
+  bool switched = (co_await awaitable_thread_has_context_switched{});
+  if (!switched)
   {
-    (dispatch)(handler_work.get_executor(),
-        [handler = std::move(handler), e]() mutable
-        {
-          std::move(handler)(e, T());
-        });
-  }
-  else
-  {
-    (post)(handler_work.get_executor(),
-        [handler = std::move(handler), e]() mutable
-        {
-          std::move(handler)(e, T());
-        });
+    (void) co_await (post)(
+        use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
   }
+
+  (dispatch)(handler_work.get_executor(),
+      [handler = std::move(handler), e]() mutable
+      {
+        std::move(handler)(e, T());
+      });
 }
 
 template <typename Executor, typename F, typename Handler>
@@ -164,22 +157,18 @@ awaitable<awaitable_thread_entry_point, Executor> co_spawn_entry_point(
     e = std::current_exception();
   }
 
-  if (co_await awaitable_thread_has_context_switched{})
-  {
-    (dispatch)(handler_work.get_executor(),
-        [handler = std::move(handler), e]() mutable
-        {
-          std::move(handler)(e);
-        });
-  }
-  else
+  bool switched = (co_await awaitable_thread_has_context_switched{});
+  if (!switched)
   {
-    (post)(handler_work.get_executor(),
-        [handler = std::move(handler), e]() mutable
-        {
-          std::move(handler)(e);
-        });
+    (void) co_await (post)(
+        use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
   }
+
+  (dispatch)(handler_work.get_executor(),
+      [handler = std::move(handler), e]() mutable
+      {
+        std::move(handler)(e);
+      });
 }
 
 template <typename T, typename Executor>
@@ -204,8 +193,8 @@ template <typename Handler, typename Executor, typename = void>
 class co_spawn_cancellation_handler
 {
 public:
-  co_spawn_cancellation_handler(const Handler& handler, const Executor& ex)
-    : ex_(boost::asio::get_associated_executor(handler, ex))
+  co_spawn_cancellation_handler(const Handler&, const Executor& ex)
+    : ex_(ex)
   {
   }
 
@@ -222,7 +211,7 @@ public:
 
 private:
   cancellation_signal signal_;
-  typename associated_executor<Handler, Executor>::type ex_;
+  Executor ex_;
 };
 
 

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

@@ -765,10 +765,21 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<RangeConnectHandler, DefaultCandidate>
 {
-  static typename Associator<RangeConnectHandler, DefaultCandidate>::type get(
-      const detail::range_connect_op<Protocol, Executor,
+  static typename Associator<RangeConnectHandler, DefaultCandidate>::type
+  get(const detail::range_connect_op<Protocol, Executor, EndpointSequence,
+        ConnectCondition, RangeConnectHandler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<RangeConnectHandler, DefaultCandidate>::get(h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<RangeConnectHandler, DefaultCandidate>::type)
+  get(const detail::range_connect_op<Protocol, Executor,
         EndpointSequence, ConnectCondition, RangeConnectHandler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<RangeConnectHandler, DefaultCandidate>::get(
+        h.handler_, c)))
   {
     return Associator<RangeConnectHandler, DefaultCandidate>::get(
         h.handler_, c);
@@ -786,10 +797,21 @@ struct associator<Associator,
   : Associator<IteratorConnectHandler, DefaultCandidate>
 {
   static typename Associator<IteratorConnectHandler, DefaultCandidate>::type
-  get(
-      const detail::iterator_connect_op<Protocol, Executor,
+  get(const detail::iterator_connect_op<Protocol, Executor, Iterator,
+        ConnectCondition, IteratorConnectHandler>& h) BOOST_ASIO_NOEXCEPT
+  {
+    return Associator<IteratorConnectHandler, DefaultCandidate>::get(
+        h.handler_);
+  }
+
+  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
+      typename Associator<IteratorConnectHandler, DefaultCandidate>::type)
+  get(const detail::iterator_connect_op<Protocol, Executor,
         Iterator, ConnectCondition, IteratorConnectHandler>& h,
-      const DefaultCandidate& c = DefaultCandidate()) BOOST_ASIO_NOEXCEPT
+      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
+    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      Associator<IteratorConnectHandler, DefaultCandidate>::get(
+        h.handler_, c)))
   {
     return Associator<IteratorConnectHandler, DefaultCandidate>::get(
         h.handler_, c);