passenger 6.0.14 → 6.0.15

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

@@ -0,0 +1,141 @@
+//
+// as_tuple.hpp
+// ~~~~~~~~~~~~
+//
+// 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_AS_TUPLE_HPP
+#define BOOST_ASIO_AS_TUPLE_HPP
+
+#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_HAS_STD_TUPLE) \
+    && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#include <boost/asio/detail/type_traits.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// A @ref completion_token adapter used to specify that the completion handler
+/// arguments should be combined into a single tuple argument.
+/**
+ * The as_tuple_t class is used to indicate that any arguments to the
+ * completion handler should be combined and passed as a single tuple argument.
+ * The arguments are first moved into a @c std::tuple and that tuple is then
+ * passed to the completion handler.
+ */
+template <typename CompletionToken>
+class as_tuple_t
+{
+public:
+  /// Tag type used to prevent the "default" constructor from being used for
+  /// conversions.
+  struct default_constructor_tag {};
+
+  /// Default constructor.
+  /**
+   * This constructor is only valid if the underlying completion token is
+   * default constructible and move constructible. The underlying completion
+   * token is itself defaulted as an argument to allow it to capture a source
+   * location.
+   */
+  BOOST_ASIO_CONSTEXPR as_tuple_t(
+      default_constructor_tag = default_constructor_tag(),
+      CompletionToken token = CompletionToken())
+    : token_(BOOST_ASIO_MOVE_CAST(CompletionToken)(token))
+  {
+  }
+
+  /// Constructor.
+  template <typename T>
+  BOOST_ASIO_CONSTEXPR explicit as_tuple_t(
+      BOOST_ASIO_MOVE_ARG(T) completion_token)
+    : token_(BOOST_ASIO_MOVE_CAST(T)(completion_token))
+  {
+  }
+
+  /// Adapts an executor to add the @c as_tuple_t completion token as the
+  /// default.
+  template <typename InnerExecutor>
+  struct executor_with_default : InnerExecutor
+  {
+    /// Specify @c as_tuple_t as the default completion token type.
+    typedef as_tuple_t default_completion_token_type;
+
+    /// Construct the adapted executor from the inner executor type.
+    template <typename InnerExecutor1>
+    executor_with_default(const InnerExecutor1& ex,
+        typename constraint<
+          conditional<
+            !is_same<InnerExecutor1, executor_with_default>::value,
+            is_convertible<InnerExecutor1, InnerExecutor>,
+            false_type
+          >::type::value
+        >::type = 0) BOOST_ASIO_NOEXCEPT
+      : InnerExecutor(ex)
+    {
+    }
+  };
+
+  /// Type alias to adapt an I/O object to use @c as_tuple_t as its
+  /// default completion token type.
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) \
+  || defined(GENERATING_DOCUMENTATION)
+  template <typename T>
+  using as_default_on_t = typename T::template rebind_executor<
+      executor_with_default<typename T::executor_type> >::other;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+  /// Function helper to adapt an I/O object to use @c as_tuple_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));
+  }
+
+//private:
+  CompletionToken token_;
+};
+
+/// Adapt a @ref completion_token to specify that the completion handler
+/// arguments should be combined into a single tuple argument.
+template <typename CompletionToken>
+BOOST_ASIO_NODISCARD inline
+BOOST_ASIO_CONSTEXPR as_tuple_t<typename decay<CompletionToken>::type>
+as_tuple(BOOST_ASIO_MOVE_ARG(CompletionToken) completion_token)
+{
+  return as_tuple_t<typename decay<CompletionToken>::type>(
+      BOOST_ASIO_MOVE_CAST(CompletionToken)(completion_token));
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/impl/as_tuple.hpp>
+
+#endif // (defined(BOOST_ASIO_HAS_STD_TUPLE)
+       //     && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES))
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_AS_TUPLE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/associated_allocator.hpp

@@ -2,7 +2,7 @@
 // associated_allocator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
@@ -38,7 +38,7 @@ struct has_allocator_type : false_type
 
 template <typename T>
 struct has_allocator_type<T,
-  typename void_type<typename T::executor_type>::type>
+  typename void_type<typename T::allocator_type>::type>
     : true_type
 {
 };
@@ -123,7 +123,7 @@ struct associated_allocator
  * @returns <tt>associated_allocator<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_allocator<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_allocator<T>::type
 get_associated_allocator(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_allocator<T>::get(t);
@@ -134,7 +134,7 @@ get_associated_allocator(const T& t) BOOST_ASIO_NOEXCEPT
  * @returns <tt>associated_allocator<T, Allocator>::get(t, a)</tt>
  */
 template <typename T, typename Allocator>
-inline typename associated_allocator<T, Allocator>::type
+BOOST_ASIO_NODISCARD inline typename associated_allocator<T, Allocator>::type
 get_associated_allocator(const T& t, const Allocator& a) BOOST_ASIO_NOEXCEPT
 {
   return associated_allocator<T, Allocator>::get(t, a);

data/src/cxx_supportlib/vendor-modified/boost/asio/associated_cancellation_slot.hpp

@@ -2,7 +2,7 @@
 // associated_cancellation_slot.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
@@ -123,7 +123,7 @@ struct associated_cancellation_slot
  * @returns <tt>associated_cancellation_slot<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_cancellation_slot<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_cancellation_slot<T>::type
 get_associated_cancellation_slot(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_cancellation_slot<T>::get(t);
@@ -135,7 +135,8 @@ get_associated_cancellation_slot(const T& t) BOOST_ASIO_NOEXCEPT
  * CancellationSlot>::get(t, st)</tt>
  */
 template <typename T, typename CancellationSlot>
-inline typename associated_cancellation_slot<T, CancellationSlot>::type
+BOOST_ASIO_NODISCARD inline
+typename associated_cancellation_slot<T, CancellationSlot>::type
 get_associated_cancellation_slot(const T& t,
     const CancellationSlot& st) BOOST_ASIO_NOEXCEPT
 {

data/src/cxx_supportlib/vendor-modified/boost/asio/associated_executor.hpp

@@ -2,7 +2,7 @@
 // associated_executor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
@@ -125,7 +125,7 @@ struct associated_executor
  * @returns <tt>associated_executor<T>::get(t)</tt>
  */
 template <typename T>
-inline typename associated_executor<T>::type
+BOOST_ASIO_NODISCARD inline typename associated_executor<T>::type
 get_associated_executor(const T& t) BOOST_ASIO_NOEXCEPT
 {
   return associated_executor<T>::get(t);
@@ -136,7 +136,7 @@ get_associated_executor(const T& t) BOOST_ASIO_NOEXCEPT
  * @returns <tt>associated_executor<T, Executor>::get(t, ex)</tt>
  */
 template <typename T, typename Executor>
-inline typename associated_executor<T, Executor>::type
+BOOST_ASIO_NODISCARD inline typename associated_executor<T, Executor>::type
 get_associated_executor(const T& t, const Executor& ex,
     typename constraint<
       is_executor<Executor>::value || execution::is_executor<Executor>::value
@@ -151,7 +151,7 @@ get_associated_executor(const T& t, const Executor& ex,
  * ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
  */
 template <typename T, typename ExecutionContext>
-inline typename associated_executor<T,
+BOOST_ASIO_NODISCARD inline typename associated_executor<T,
   typename ExecutionContext::executor_type>::type
 get_associated_executor(const T& t, ExecutionContext& ctx,
     typename constraint<is_convertible<ExecutionContext&,

data/src/cxx_supportlib/vendor-modified/boost/asio/associator.hpp

@@ -2,7 +2,7 @@
 // associator.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)

data/src/cxx_supportlib/vendor-modified/boost/asio/async_result.hpp

@@ -2,7 +2,7 @@
 // async_result.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
@@ -312,6 +312,12 @@ struct are_simple_completion_signatures<Sig0, Sig1, Sig2>
 {
 };
 
+template <>
+struct simple_completion_signature<void>
+{
+  typedef void type;
+};
+
 template <typename R>
 struct simple_completion_signature<R()>
 {
@@ -802,6 +808,40 @@ struct async_result_has_initiate_memfn
   BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2)
 #endif
 
+#if defined(GENERATING_DOCUMENTATION)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
+#elif defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
+#elif defined(BOOST_ASIO_HAS_DECLTYPE)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+  auto
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr) -> decltype expr
+#else
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(ct, sig) \
+  BOOST_ASIO_INITFN_RESULT_TYPE(ct, sig)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX2(ct, sig0, sig1) \
+  BOOST_ASIO_INITFN_RESULT_TYPE2(ct, sig0, sig1)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX3(ct, sig0, sig1, sig2) \
+  BOOST_ASIO_INITFN_RESULT_TYPE3(ct, sig0, sig1, sig2)
+# define BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX(expr)
+#endif
+
 #if defined(GENERATING_DOCUMENTATION)
 # define BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(ct, sig, expr) \
   void_or_deduced
@@ -1196,6 +1236,328 @@ BOOST_ASIO_CONCEPT completion_token_for =
 
 namespace detail {
 
+struct async_operation_probe {};
+struct async_operation_probe_result {};
+
+template <typename Call, typename = void>
+struct is_async_operation_call : false_type
+{
+};
+
+template <typename Call>
+struct is_async_operation_call<Call,
+    typename void_type<
+      typename enable_if<
+        is_same<
+          typename result_of<Call>::type,
+          async_operation_probe_result
+        >::value
+      >::type
+    >::type> : true_type
+{
+};
+
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename... Signatures>
+class async_result<detail::async_operation_probe, Signatures...>
+{
+public:
+  typedef detail::async_operation_probe_result return_type;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
+      detail::async_operation_probe, BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  {
+    return return_type();
+  }
+};
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+namespace detail {
+
+struct async_result_probe_base
+{
+  typedef detail::async_operation_probe_result return_type;
+
+  template <typename Initiation>
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
+      detail::async_operation_probe)
+  {
+    return return_type();
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation), \
+      detail::async_operation_probe, \
+      BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS(n)) \
+  { \
+    return return_type(); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+};
+
+} // namespace detail
+
+template <typename Sig0>
+class async_result<detail::async_operation_probe, Sig0>
+  : public detail::async_result_probe_base {};
+
+template <typename Sig0, typename Sig1>
+class async_result<detail::async_operation_probe, Sig0, Sig1>
+  : public detail::async_result_probe_base {};
+
+template <typename Sig0, typename Sig1, typename Sig2>
+class async_result<detail::async_operation_probe, Sig0, Sig1, Sig2>
+  : public detail::async_result_probe_base {};
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#if defined(GENERATION_DOCUMENTATION)
+
+/// The is_async_operation trait detects whether a type @c T and arguments
+/// @c Args... may be used to initiate an asynchronous operation.
+/**
+ * Class template @c is_async_operation is a trait is derived from @c true_type
+ * if the expression <tt>T(Args..., token)</tt> initiates an asynchronous
+ * operation, where @c token is an unspecified completion token type. Otherwise,
+ * @c is_async_operation is derived from @c false_type.
+ */
+template <typename T, typename... Args>
+struct is_async_operation : integral_constant<bool, automatically_determined>
+{
+};
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Args>
+struct is_async_operation :
+  detail::is_async_operation_call<
+    T(Args..., detail::async_operation_probe)>
+{
+};
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename = void, typename = void, typename = void,
+    typename = void, typename = void, typename = void, typename = void,
+    typename = void, typename = void>
+struct is_async_operation :
+  detail::is_async_operation_call<
+    T(detail::async_operation_probe)>
+{
+};
+
+#define BOOST_ASIO_PRIVATE_IS_ASYNC_OP_DEF(n) \
+  template <typename T, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct is_async_operation<T, BOOST_ASIO_VARIADIC_TARGS(n)> : \
+    detail::is_async_operation_call< \
+      T(BOOST_ASIO_VARIADIC_TARGS(n), detail::async_operation_probe)> \
+  { \
+  }; \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_IS_ASYNC_OP_DEF)
+#undef BOOST_ASIO_PRIVATE_IS_ASYNC_OP_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#if defined(BOOST_ASIO_HAS_CONCEPTS) \
+  && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Args>
+BOOST_ASIO_CONCEPT async_operation = is_async_operation<T, Args...>::value;
+
+#define BOOST_ASIO_ASYNC_OPERATION(t) \
+  ::boost::asio::async_operation<t>
+#define BOOST_ASIO_ASYNC_OPERATION1(t, a0) \
+  ::boost::asio::async_operation<t, a0>
+#define BOOST_ASIO_ASYNC_OPERATION2(t, a0, a1) \
+  ::boost::asio::async_operation<t, a0, a1>
+#define BOOST_ASIO_ASYNC_OPERATION3(t, a0, a1, a2) \
+  ::boost::asio::async_operation<t, a0, a1, a2>
+
+#else // defined(BOOST_ASIO_HAS_CONCEPTS)
+      //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#define BOOST_ASIO_ASYNC_OPERATION(t) typename
+#define BOOST_ASIO_ASYNC_OPERATION1(t, a0) typename
+#define BOOST_ASIO_ASYNC_OPERATION2(t, a0, a1) typename
+#define BOOST_ASIO_ASYNC_OPERATION3(t, a0, a1, a2) typename
+
+#endif // defined(BOOST_ASIO_HAS_CONCEPTS)
+       //   && defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+namespace detail {
+
+struct completion_signature_probe {};
+
+template <typename T>
+struct completion_signature_probe_result
+{
+  typedef T type;
+};
+
+template <>
+struct completion_signature_probe_result<void>
+{
+};
+
+} // namespace detail
+
+#if !defined(GENERATING_DOCUMENTATION)
+#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename... Signatures>
+class async_result<detail::completion_signature_probe, Signatures...>
+{
+public:
+  typedef detail::completion_signature_probe_result<void> return_type;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
+      detail::completion_signature_probe, BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  {
+    return return_type();
+  }
+};
+
+template <typename Signature>
+class async_result<detail::completion_signature_probe, Signature>
+{
+public:
+  typedef detail::completion_signature_probe_result<Signature> return_type;
+
+  template <typename Initiation, typename... InitArgs>
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
+      detail::completion_signature_probe, BOOST_ASIO_MOVE_ARG(InitArgs)...)
+  {
+    return return_type();
+  }
+};
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+namespace detail {
+
+template <typename Signature>
+class async_result_sig_probe_base
+{
+public:
+  typedef detail::completion_signature_probe_result<Signature> return_type;
+
+  template <typename Initiation>
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation),
+      detail::async_operation_probe)
+  {
+    return return_type();
+  }
+
+#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
+  template <typename Initiation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  static return_type initiate(BOOST_ASIO_MOVE_ARG(Initiation), \
+      detail::completion_signature_probe, \
+      BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS(n)) \
+  { \
+    return return_type(); \
+  } \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
+#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
+};
+
+} // namespace detail
+
+template <>
+class async_result<detail::completion_signature_probe>
+  : public detail::async_result_sig_probe_base<void> {};
+
+template <typename Sig0>
+class async_result<detail::completion_signature_probe, Sig0>
+  : public detail::async_result_sig_probe_base<Sig0> {};
+
+template <typename Sig0, typename Sig1>
+class async_result<detail::completion_signature_probe, Sig0, Sig1>
+  : public detail::async_result_sig_probe_base<void> {};
+
+template <typename Sig0, typename Sig1, typename Sig2>
+class async_result<detail::completion_signature_probe, Sig0, Sig1, Sig2>
+  : public detail::async_result_sig_probe_base<void> {};
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// The completion_signature_of trait determines the completion signature
+/// of an asynchronous operation.
+/**
+ * Class template @c completion_signature_of is a trait with a member type
+ * alias @c type that denotes the completion signature of the asynchronous
+ * operation initiated by the expression <tt>T(Args..., token)</tt> operation,
+ * where @c token is an unspecified completion token type. If the asynchronous
+ * operation does not have exactly one completion signature, the instantion of
+ * the trait is well-formed but the member type alias @c type is omitted. If
+ * the expression <tt>T(Args..., token)</tt> is not an asynchronous operation
+ * then use of the trait is ill-formed.
+ */
+template <typename T, typename... Args>
+struct completion_signature_of
+{
+  typedef automatically_determined type;
+};
+
+template <typename T, typename... Args>
+using completion_signature_of_t =
+  typename completion_signature_of<T, Args...>::type;
+
+#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename... Args>
+struct completion_signature_of :
+  result_of<T(Args..., detail::completion_signature_probe)>::type
+{
+};
+
+#if defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+template <typename T, typename... Args>
+using completion_signature_of_t =
+  typename completion_signature_of<T, Args...>::type;
+#endif // defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES)
+
+#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+template <typename T, typename = void, typename = void, typename = void,
+    typename = void, typename = void, typename = void, typename = void,
+    typename = void, typename = void>
+struct completion_signature_of :
+  result_of<T(detail::completion_signature_probe)>::type
+{
+};
+
+#define BOOST_ASIO_PRIVATE_COMPLETION_SIG_OF_DEF(n) \
+  template <typename T, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  struct completion_signature_of<T, BOOST_ASIO_VARIADIC_TARGS(n)> : \
+    result_of< \
+      T(BOOST_ASIO_VARIADIC_TARGS(n), \
+        detail::completion_signature_probe)>::type \
+  { \
+  }; \
+  /**/
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_COMPLETION_SIG_OF_DEF)
+#undef BOOST_ASIO_PRIVATE_COMPLETION_SIG_OF_DEF
+
+#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+namespace detail {
+
 template <typename T, typename = void>
 struct default_completion_token_impl
 {

data/src/cxx_supportlib/vendor-modified/boost/asio/awaitable.hpp

@@ -2,7 +2,7 @@
 // awaitable.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
@@ -25,6 +25,7 @@
 # include <experimental/coroutine>
 #endif // defined(BOOST_ASIO_HAS_STD_COROUTINE)
 
+#include <utility>
 #include <boost/asio/any_io_executor.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -76,6 +77,14 @@ public:
       frame_->destroy();
   }
 
+  /// Move assignment.
+  awaitable& operator=(awaitable&& other) noexcept
+  {
+    if (this != &other)
+      frame_ = std::exchange(other.frame_, nullptr);
+    return *this;
+  }
+
   /// Checks if the awaitable refers to a future result.
   bool valid() const noexcept
   {