passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // experimental/detail/impl/channel_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -23,7 +23,8 @@ namespace experimental {
 namespace detail {
 
 template <typename Mutex>
-inline channel_service<Mutex>::channel_service(execution_context& ctx)
+inline channel_service<Mutex>::channel_service(
+    boost::asio::execution_context& ctx)
   : boost::asio::detail::execution_context_service_base<channel_service>(ctx),
     mutex_(),
     impl_list_(0)
@@ -156,7 +157,7 @@ inline void channel_service<Mutex>::base_destroy(
 template <typename Mutex>
 inline std::size_t channel_service<Mutex>::capacity(
     const channel_service<Mutex>::base_implementation_type& impl)
-  const BOOST_ASIO_NOEXCEPT
+  const noexcept
 {
   typename Mutex::scoped_lock lock(impl.mutex_);
 
@@ -166,7 +167,7 @@ inline std::size_t channel_service<Mutex>::capacity(
 template <typename Mutex>
 inline bool channel_service<Mutex>::is_open(
     const channel_service<Mutex>::base_implementation_type& impl)
-  const BOOST_ASIO_NOEXCEPT
+  const noexcept
 {
   typename Mutex::scoped_lock lock(impl.mutex_);
 
@@ -205,7 +206,7 @@ void channel_service<Mutex>::close(
     {
       impl.waiters_.pop();
       traits_type::invoke_receive_closed(
-          complete_receive<payload_type,
+          post_receive<payload_type,
             typename traits_type::receive_closed_signature>(
               static_cast<channel_receive<payload_type>*>(op)));
     }
@@ -239,7 +240,7 @@ void channel_service<Mutex>::cancel(
     {
       impl.waiters_.pop();
       traits_type::invoke_receive_cancelled(
-          complete_receive<payload_type,
+          post_receive<payload_type,
             typename traits_type::receive_cancelled_signature>(
               static_cast<channel_receive<payload_type>*>(op)));
     }
@@ -278,7 +279,7 @@ void channel_service<Mutex>::cancel_by_key(
       {
         impl.waiters_.pop();
         traits_type::invoke_receive_cancelled(
-            complete_receive<payload_type,
+            post_receive<payload_type,
               typename traits_type::receive_cancelled_signature>(
                 static_cast<channel_receive<payload_type>*>(op)));
       }
@@ -303,7 +304,7 @@ void channel_service<Mutex>::cancel_by_key(
 template <typename Mutex>
 inline bool channel_service<Mutex>::ready(
     const channel_service<Mutex>::base_implementation_type& impl)
-  const BOOST_ASIO_NOEXCEPT
+  const noexcept
 {
   typename Mutex::scoped_lock lock(impl.mutex_);
 
@@ -315,7 +316,7 @@ template <typename Message, typename Traits,
     typename... Signatures, typename... Args>
 bool channel_service<Mutex>::try_send(
     channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-    BOOST_ASIO_MOVE_ARG(Args)... args)
+    bool via_dispatch, Args&&... args)
 {
   typedef typename implementation_type<Traits,
       Signatures...>::payload_type payload_type;
@@ -330,7 +331,7 @@ bool channel_service<Mutex>::try_send(
     }
   case buffer:
     {
-      impl.buffer_push(Message(0, BOOST_ASIO_MOVE_CAST(Args)(args)...));
+      impl.buffer_push(Message(0, static_cast<Args&&>(args)...));
       impl.receive_state_ = buffer;
       if (impl.buffer_size() == impl.max_buffer_size_)
         impl.send_state_ = block;
@@ -338,13 +339,17 @@ bool channel_service<Mutex>::try_send(
     }
   case waiter:
     {
-      payload_type payload(Message(0, BOOST_ASIO_MOVE_CAST(Args)(args)...));
+      payload_type payload(Message(0, static_cast<Args&&>(args)...));
       channel_receive<payload_type>* receive_op =
         static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
       impl.waiters_.pop();
-      receive_op->complete(BOOST_ASIO_MOVE_CAST(payload_type)(payload));
       if (impl.waiters_.empty())
         impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+      lock.unlock();
+      if (via_dispatch)
+        receive_op->dispatch(static_cast<payload_type&&>(payload));
+      else
+        receive_op->post(static_cast<payload_type&&>(payload));
       return true;
     }
   case closed:
@@ -360,7 +365,7 @@ template <typename Message, typename Traits,
     typename... Signatures, typename... Args>
 std::size_t channel_service<Mutex>::try_send_n(
     channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-		std::size_t count, BOOST_ASIO_MOVE_ARG(Args)... args)
+		std::size_t count, bool via_dispatch, Args&&... args)
 {
   typedef typename implementation_type<Traits,
       Signatures...>::payload_type payload_type;
@@ -382,7 +387,7 @@ std::size_t channel_service<Mutex>::try_send_n(
     return 0;
   }
 
-  payload_type payload(Message(0, BOOST_ASIO_MOVE_CAST(Args)(args)...));
+  payload_type payload(Message(0, static_cast<Args&&>(args)...));
 
   for (std::size_t i = 0; i < count; ++i)
   {
@@ -395,7 +400,7 @@ std::size_t channel_service<Mutex>::try_send_n(
     case buffer:
       {
         i += impl.buffer_push_n(count - i,
-            BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+            static_cast<payload_type&&>(payload));
         impl.receive_state_ = buffer;
         if (impl.buffer_size() == impl.max_buffer_size_)
           impl.send_state_ = block;
@@ -406,9 +411,13 @@ std::size_t channel_service<Mutex>::try_send_n(
         channel_receive<payload_type>* receive_op =
           static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
         impl.waiters_.pop();
-        receive_op->complete(payload);
         if (impl.waiters_.empty())
           impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+        lock.unlock();
+        if (via_dispatch)
+          receive_op->dispatch(payload);
+        else
+          receive_op->post(payload);
         break;
       }
     case closed:
@@ -457,9 +466,9 @@ void channel_service<Mutex>::start_send_op(
       channel_receive<payload_type>* receive_op =
         static_cast<channel_receive<payload_type>*>(impl.waiters_.front());
       impl.waiters_.pop();
-      receive_op->complete(send_op->get_payload());
       if (impl.waiters_.empty())
         impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+      receive_op->post(send_op->get_payload());
       send_op->immediate();
       break;
     }
@@ -476,7 +485,7 @@ template <typename Mutex>
 template <typename Traits, typename... Signatures, typename Handler>
 bool channel_service<Mutex>::try_receive(
     channel_service<Mutex>::implementation_type<Traits, Signatures...>& impl,
-		BOOST_ASIO_MOVE_ARG(Handler) handler)
+		Handler&& handler)
 {
   typedef typename implementation_type<Traits,
       Signatures...>::payload_type payload_type;
@@ -498,7 +507,7 @@ bool channel_service<Mutex>::try_receive(
         impl.buffer_pop();
         impl.buffer_push(send_op->get_payload());
         impl.waiters_.pop();
-        send_op->complete();
+        send_op->post();
       }
       else
       {
@@ -509,8 +518,8 @@ bool channel_service<Mutex>::try_receive(
       }
       lock.unlock();
       boost::asio::detail::non_const_lvalue<Handler> handler2(handler);
-      channel_handler<payload_type, typename decay<Handler>::type>(
-          BOOST_ASIO_MOVE_CAST(payload_type)(payload), handler2.value)();
+      channel_handler<payload_type, decay_t<Handler>>(
+          static_cast<payload_type&&>(payload), handler2.value)();
       return true;
     }
   case waiter:
@@ -519,13 +528,13 @@ bool channel_service<Mutex>::try_receive(
         static_cast<channel_send<payload_type>*>(impl.waiters_.front());
       payload_type payload = send_op->get_payload();
       impl.waiters_.pop();
-      send_op->complete();
       if (impl.waiters_.front() == 0)
         impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
+      send_op->post();
       lock.unlock();
       boost::asio::detail::non_const_lvalue<Handler> handler2(handler);
-      channel_handler<payload_type, typename decay<Handler>::type>(
-          BOOST_ASIO_MOVE_CAST(payload_type)(payload), handler2.value)();
+      channel_handler<payload_type, decay_t<Handler>>(
+          static_cast<payload_type&&>(payload), handler2.value)();
       return true;
     }
   case closed:
@@ -562,14 +571,14 @@ void channel_service<Mutex>::start_receive_op(
   case buffer:
     {
       payload_type payload(
-          BOOST_ASIO_MOVE_CAST(payload_type)(impl.buffer_front()));
+          static_cast<payload_type&&>(impl.buffer_front()));
       if (channel_send<payload_type>* send_op =
           static_cast<channel_send<payload_type>*>(impl.waiters_.front()))
       {
         impl.buffer_pop();
         impl.buffer_push(send_op->get_payload());
         impl.waiters_.pop();
-        send_op->complete();
+        send_op->post();
       }
       else
       {
@@ -578,7 +587,7 @@ void channel_service<Mutex>::start_receive_op(
           impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
         impl.send_state_ = (impl.send_state_ == closed) ? closed : buffer;
       }
-      receive_op->immediate(BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+      receive_op->immediate(static_cast<payload_type&&>(payload));
       break;
     }
   case waiter:
@@ -587,17 +596,17 @@ void channel_service<Mutex>::start_receive_op(
         static_cast<channel_send<payload_type>*>(impl.waiters_.front());
       payload_type payload = send_op->get_payload();
       impl.waiters_.pop();
-      send_op->complete();
       if (impl.waiters_.front() == 0)
         impl.receive_state_ = (impl.send_state_ == closed) ? closed : block;
-      receive_op->immediate(BOOST_ASIO_MOVE_CAST(payload_type)(payload));
+      send_op->post();
+      receive_op->immediate(static_cast<payload_type&&>(payload));
       break;
     }
   case closed:
   default:
     {
       traits_type::invoke_receive_closed(
-          complete_receive<payload_type,
+          post_receive<payload_type,
             typename traits_type::receive_closed_signature>(receive_op));
       break;
     }

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

@@ -2,7 +2,7 @@
 // experimental/impl/as_single.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -16,16 +16,11 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-
 #include <tuple>
-
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
-#include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_cont_helpers.hpp>
-#include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/type_traits.hpp>
-#include <boost/asio/detail/variadic_templates.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -43,65 +38,38 @@ public:
 
   template <typename CompletionToken>
   as_single_handler(as_single_t<CompletionToken> e)
-    : handler_(BOOST_ASIO_MOVE_CAST(CompletionToken)(e.token_))
+    : handler_(static_cast<CompletionToken&&>(e.token_))
   {
   }
 
   template <typename RedirectedHandler>
-  as_single_handler(BOOST_ASIO_MOVE_ARG(RedirectedHandler) h)
-    : handler_(BOOST_ASIO_MOVE_CAST(RedirectedHandler)(h))
+  as_single_handler(RedirectedHandler&& h)
+    : handler_(static_cast<RedirectedHandler&&>(h))
   {
   }
 
   void operator()()
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)();
+    static_cast<Handler&&>(handler_)();
   }
 
   template <typename Arg>
-  void operator()(BOOST_ASIO_MOVE_ARG(Arg) arg)
+  void operator()(Arg&& arg)
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
-        BOOST_ASIO_MOVE_CAST(Arg)(arg));
+    static_cast<Handler&&>(handler_)(static_cast<Arg&&>(arg));
   }
 
   template <typename... Args>
-  void operator()(BOOST_ASIO_MOVE_ARG(Args)... args)
+  void operator()(Args&&... args)
   {
-    BOOST_ASIO_MOVE_OR_LVALUE(Handler)(handler_)(
-        std::make_tuple(BOOST_ASIO_MOVE_CAST(Args)(args)...));
+    static_cast<Handler&&>(handler_)(
+        std::make_tuple(static_cast<Args&&>(args)...));
   }
 
 //private:
   Handler handler_;
 };
 
-template <typename Handler>
-inline asio_handler_allocate_is_deprecated
-asio_handler_allocate(std::size_t size,
-    as_single_handler<Handler>* this_handler)
-{
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-  boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
-  return asio_handler_allocate_is_no_longer_used();
-#else // defined(BOOST_ASIO_NO_DEPRECATED)
-  return boost_asio_handler_alloc_helpers::allocate(
-      size, this_handler->handler_);
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-}
-
-template <typename Handler>
-inline asio_handler_deallocate_is_deprecated
-asio_handler_deallocate(void* pointer, std::size_t size,
-    as_single_handler<Handler>* this_handler)
-{
-  boost_asio_handler_alloc_helpers::deallocate(
-      pointer, size, this_handler->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-  return asio_handler_deallocate_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-}
-
 template <typename Handler>
 inline bool asio_handler_is_continuation(
     as_single_handler<Handler>* this_handler)
@@ -110,30 +78,6 @@ inline bool asio_handler_is_continuation(
         this_handler->handler_);
 }
 
-template <typename Function, typename Handler>
-inline asio_handler_invoke_is_deprecated
-asio_handler_invoke(Function& function,
-    as_single_handler<Handler>* this_handler)
-{
-  boost_asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-  return asio_handler_invoke_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-}
-
-template <typename Function, typename Handler>
-inline asio_handler_invoke_is_deprecated
-asio_handler_invoke(const Function& function,
-    as_single_handler<Handler>* this_handler)
-{
-  boost_asio_handler_invoke_helpers::invoke(
-      function, this_handler->handler_);
-#if defined(BOOST_ASIO_NO_DEPRECATED)
-  return asio_handler_invoke_is_no_longer_used();
-#endif // defined(BOOST_ASIO_NO_DEPRECATED)
-}
-
 template <typename Signature>
 struct as_single_signature
 {
@@ -155,7 +99,7 @@ struct as_single_signature<R(Arg)>
 template <typename R, typename... Args>
 struct as_single_signature<R(Args...)>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>);
+  typedef R type(std::tuple<decay_t<Args>...>);
 };
 
 } // namespace detail
@@ -166,44 +110,41 @@ struct as_single_signature<R(Args...)>
 template <typename CompletionToken, typename Signature>
 struct async_result<experimental::as_single_t<CompletionToken>, Signature>
 {
-  typedef typename async_result<CompletionToken,
-    typename experimental::detail::as_single_signature<Signature>::type>
-      ::return_type return_type;
-
   template <typename Initiation>
   struct init_wrapper
   {
     init_wrapper(Initiation init)
-      : initiation_(BOOST_ASIO_MOVE_CAST(Initiation)(init))
+      : initiation_(static_cast<Initiation&&>(init))
     {
     }
 
     template <typename Handler, typename... Args>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler,
-        BOOST_ASIO_MOVE_ARG(Args)... args)
+    void operator()(Handler&& handler, Args&&... args)
     {
-      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
-          experimental::detail::as_single_handler<
-            typename decay<Handler>::type>(
-              BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      static_cast<Initiation&&>(initiation_)(
+          experimental::detail::as_single_handler<decay_t<Handler>>(
+            static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static return_type initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
-      BOOST_ASIO_MOVE_ARG(Args)... args)
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
+    -> decltype(
+      async_initiate<CompletionToken,
+        typename experimental::detail::as_single_signature<Signature>::type>(
+          init_wrapper<decay_t<Initiation>>(
+            static_cast<Initiation&&>(initiation)),
+          token.token_, static_cast<Args&&>(args)...))
   {
     return async_initiate<CompletionToken,
       typename experimental::detail::as_single_signature<Signature>::type>(
-        init_wrapper<typename decay<Initiation>::type>(
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
-        token.token_, BOOST_ASIO_MOVE_CAST(Args)(args)...);
+        init_wrapper<decay_t<Initiation>>(
+          static_cast<Initiation&&>(initiation)),
+        token.token_, static_cast<Args&&>(args)...);
   }
 };
 
@@ -213,19 +154,15 @@ 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)
-    BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::as_single_handler<Handler>& h) 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)))
+  static auto get(const experimental::detail::as_single_handler<Handler>& h,
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }

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

@@ -2,7 +2,7 @@
 // experimental/impl/channel_error.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -29,7 +29,7 @@ namespace detail {
 class channel_category : public boost::system::error_category
 {
 public:
-  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
+  const char* name() const noexcept
   {
     return "asio.channel";
   }

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

@@ -2,7 +2,7 @@
 // experimental/impl/co_composed.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -588,7 +588,7 @@ public:
   using co_composed_handler_base<Executors,
     Handler, Return>::co_composed_handler_base;
 
-  using result_type = std::tuple<typename decay<Args>::type...>;
+  using result_type = std::tuple<decay_t<Args>...>;
 
   template <typename... T>
   void operator()(T&&... args)
@@ -619,7 +619,7 @@ public:
   using co_composed_handler_base<Executors,
     Handler, Return>::co_composed_handler_base;
 
-  using args_type = std::tuple<typename decay<Args>::type...>;
+  using args_type = std::tuple<decay_t<Args>...>;
   using result_type = std::tuple<boost::system::error_code, args_type>;
 
   template <typename... T>
@@ -652,7 +652,7 @@ public:
   using co_composed_handler_base<Executors,
     Handler, Return>::co_composed_handler_base;
 
-  using args_type = std::tuple<typename decay<Args>::type...>;
+  using args_type = std::tuple<decay_t<Args>...>;
   using result_type = std::tuple<std::exception_ptr, args_type>;
 
   template <typename... T>
@@ -960,7 +960,7 @@ public:
               Return> composed_handler(a.promise_);
 
             Handler handler(std::move(a.promise_.state_.handler_));
-            std::tuple<typename decay<Args>::type...> result(
+            std::tuple<decay_t<Args>...> result(
                 std::move(static_cast<std::tuple<Args&&...>>(a.result_)));
 
             co_composed_handler_base<Executors, Handler,
@@ -1027,7 +1027,7 @@ public:
   template <typename Handler, typename... InitArgs>
   void operator()(Handler&& handler, InitArgs&&... init_args) const &
   {
-    using handler_type = typename decay<Handler>::type;
+    using handler_type = decay_t<Handler>;
     using returns_type = co_composed_returns<Signatures...>;
     co_composed_on_suspend on_suspend{};
     implementation_(
@@ -1041,7 +1041,7 @@ public:
   template <typename Handler, typename... InitArgs>
   void operator()(Handler&& handler, InitArgs&&... init_args) &&
   {
-    using handler_type = typename decay<Handler>::type;
+    using handler_type = decay_t<Handler>;
     using returns_type = co_composed_returns<Signatures...>;
     co_composed_on_suspend on_suspend{};
     std::move(implementation_)(
@@ -1063,7 +1063,7 @@ make_initiate_co_composed(Implementation&& implementation,
     composed_io_executors<Executors>&& executors)
 {
   return initiate_co_composed<
-    typename decay<Implementation>::type, Executors, Signatures...>(
+    decay_t<Implementation>, Executors, Signatures...>(
         std::forward<Implementation>(implementation), std::move(executors));
 }
 
@@ -1095,22 +1095,21 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type
-  get(const experimental::detail::co_composed_handler<
-        Executors, Handler, Return, Signature>& h) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::co_composed_handler<
+        Executors, Handler, Return, Signature>& h) noexcept
   {
     return Associator<Handler, DefaultCandidate>::get(
         h.promise().state().handler());
   }
 
-  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
-      typename Associator<Handler, DefaultCandidate>::type)
-  get(const experimental::detail::co_composed_handler<
+  static auto get(
+      const experimental::detail::co_composed_handler<
         Executors, Handler, Return, Signature>& h,
-      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
+      const DefaultCandidate& c) noexcept
+    -> decltype(
       Associator<Handler, DefaultCandidate>::get(
-        h.promise().state().handler(), c)))
+        h.promise().state().handler(), c))
   {
     return Associator<Handler, DefaultCandidate>::get(
         h.promise().state().handler(), c);

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

@@ -46,18 +46,18 @@ struct coro_cancellation_source
   }
 
   template <typename Filter>
-  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+  void reset_cancellation_state(Filter&& filter)
   {
-    state = cancellation_state(slot, BOOST_ASIO_MOVE_CAST(Filter)(filter));
+    state = cancellation_state(slot, static_cast<Filter&&>(filter));
   }
 
   template <typename InFilter, typename OutFilter>
-  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(InFilter) in_filter,
-      BOOST_ASIO_MOVE_ARG(OutFilter) out_filter)
+  void reset_cancellation_state(InFilter&& in_filter,
+      OutFilter&& out_filter)
   {
     state = cancellation_state(slot,
-        BOOST_ASIO_MOVE_CAST(InFilter)(in_filter),
-        BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter));
+        static_cast<InFilter&&>(in_filter),
+        static_cast<OutFilter&&>(out_filter));
   }
 
   bool throw_if_cancelled() const
@@ -768,11 +768,11 @@ struct coro_promise final :
       auto await_resume()
       {
         return src_->reset_cancellation_state(
-            BOOST_ASIO_MOVE_CAST(Filter)(filter_));
+            static_cast<Filter&&>(filter_));
       }
     };
 
-    return result{cancel, BOOST_ASIO_MOVE_CAST(Filter)(reset.filter)};
+    return result{cancel, static_cast<Filter&&>(reset.filter)};
   }
 
   // This await transformation resets the associated cancellation state.
@@ -799,14 +799,14 @@ struct coro_promise final :
       auto await_resume()
       {
         return src_->reset_cancellation_state(
-            BOOST_ASIO_MOVE_CAST(InFilter)(in_filter_),
-            BOOST_ASIO_MOVE_CAST(OutFilter)(out_filter_));
+            static_cast<InFilter&&>(in_filter_),
+            static_cast<OutFilter&&>(out_filter_));
       }
     };
 
     return result{cancel,
-        BOOST_ASIO_MOVE_CAST(InFilter)(reset.in_filter),
-        BOOST_ASIO_MOVE_CAST(OutFilter)(reset.out_filter)};
+        static_cast<InFilter&&>(reset.in_filter),
+        static_cast<OutFilter&&>(reset.out_filter)};
   }
 
   // This await transformation determines whether cancellation is propagated as
@@ -895,7 +895,7 @@ struct coro_promise final :
 
   template <typename Op>
   auto await_transform(Op&& op,
-      typename constraint<is_async_operation<Op>::value>::type = 0)
+      constraint_t<is_async_operation<Op>::value> = 0)
   {
     if ((cancel->state.cancelled() != cancellation_type::none)
         && cancel->throw_if_cancelled_)
@@ -903,7 +903,7 @@ struct coro_promise final :
       boost::asio::detail::throw_error(
           boost::asio::error::operation_aborted, "coro-cancelled");
     }
-    using signature = typename completion_signature_of<Op>::type;
+    using signature = completion_signature_of_t<Op>;
     using result_type = detail::coro_completion_handler_type_t<signature>;
     using handler_type =
       typename detail::coro_completion_handler_type<signature>::template