passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // experimental/impl/parallel_group.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)
@@ -85,12 +85,12 @@ private:
 template <typename Handler, typename... Ops>
 struct parallel_group_completion_handler
 {
-  typedef typename decay<
-      typename prefer_result<
-        typename associated_executor<Handler>::type,
+  typedef decay_t<
+      prefer_result_t<
+        associated_executor_t<Handler>,
         execution::outstanding_work_t::tracked_t
-      >::type
-    >::type executor_type;
+      >
+    > executor_type;
 
   parallel_group_completion_handler(Handler&& h)
     : handler_(std::move(h)),
@@ -137,7 +137,7 @@ struct parallel_group_completion_handler
   std::tuple<
       parallel_group_op_result<
         typename parallel_op_signature_as_tuple<
-          typename completion_signature_of<Ops>::type
+          completion_signature_of_t<Ops>
         >::type
       >...
     > args_{};
@@ -190,7 +190,7 @@ struct parallel_group_op_handler
   typedef boost::asio::cancellation_slot cancellation_slot_type;
 
   parallel_group_op_handler(
-    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state)
+    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state)
     : state_(std::move(state))
   {
   }
@@ -231,7 +231,7 @@ struct parallel_group_op_handler
       boost::asio::dispatch(std::move(state_->handler_));
   }
 
-  std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+  std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state_;
 };
 
 // Handler for an individual operation within the parallel group that has an
@@ -246,7 +246,7 @@ struct parallel_group_op_handler_with_executor :
   typedef Executor executor_type;
 
   parallel_group_op_handler_with_executor(
-      std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state,
+      std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state,
       executor_type ex)
     : parallel_group_op_handler<I, Condition, Handler, Ops...>(std::move(state))
   {
@@ -270,7 +270,7 @@ struct parallel_group_op_handler_with_executor :
   {
     cancel_proxy(
         std::shared_ptr<parallel_group_state<
-          Condition, Handler, Ops...> > state,
+          Condition, Handler, Ops...>> state,
         executor_type ex)
       : state_(std::move(state)),
         executor_(std::move(ex))
@@ -287,7 +287,7 @@ struct parallel_group_op_handler_with_executor :
       }
     }
 
-    std::weak_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+    std::weak_ptr<parallel_group_state<Condition, Handler, Ops...>> state_;
     boost::asio::cancellation_signal signal_;
     executor_type executor_;
   };
@@ -302,9 +302,9 @@ struct parallel_group_op_launcher
   template <typename Condition, typename Handler, typename... Ops>
   static void launch(Op& op,
     const std::shared_ptr<parallel_group_state<
-      Condition, Handler, Ops...> >& state)
+      Condition, Handler, Ops...>>& state)
   {
-    typedef typename associated_executor<Op>::type ex_type;
+    typedef associated_executor_t<Op> ex_type;
     ex_type ex = boost::asio::get_associated_executor(op);
     std::move(op)(
         parallel_group_op_handler_with_executor<ex_type, I,
@@ -315,18 +315,18 @@ struct parallel_group_op_launcher
 // Specialised launcher for operations that specify no executor.
 template <std::size_t I, typename Op>
 struct parallel_group_op_launcher<I, Op,
-    typename enable_if<
+    enable_if_t<
       is_same<
         typename associated_executor<
           Op>::asio_associated_executor_is_unspecialised,
         void
       >::value
-    >::type>
+    >>
 {
   template <typename Condition, typename Handler, typename... Ops>
   static void launch(Op& op,
     const std::shared_ptr<parallel_group_state<
-      Condition, Handler, Ops...> >& state)
+      Condition, Handler, Ops...>>& state)
   {
     std::move(op)(
         parallel_group_op_handler<I, Condition, Handler, Ops...>(state));
@@ -337,7 +337,7 @@ template <typename Condition, typename Handler, typename... Ops>
 struct parallel_group_cancellation_handler
 {
   parallel_group_cancellation_handler(
-    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state)
+    std::shared_ptr<parallel_group_state<Condition, Handler, Ops...>> state)
     : state_(std::move(state))
   {
   }
@@ -354,7 +354,7 @@ struct parallel_group_cancellation_handler
             state->cancellation_signals_[i].emit(cancel_type);
   }
 
-  std::weak_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+  std::weak_ptr<parallel_group_state<Condition, Handler, Ops...>> state_;
 };
 
 template <typename Condition, typename Handler,
@@ -364,7 +364,7 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
 {
   // Get the user's completion handler's cancellation slot, so that we can allow
   // cancellation of the entire group.
-  typename associated_cancellation_slot<Handler>::type slot
+  associated_cancellation_slot_t<Handler> slot
     = boost::asio::get_associated_cancellation_slot(handler);
 
   // Create the shared state for the operation.
@@ -391,7 +391,7 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
   if (slot.is_connected())
     slot.template emplace<
       parallel_group_cancellation_handler<
-        Condition, Handler, Ops...> >(state);
+        Condition, Handler, Ops...>>(state);
 }
 
 // Proxy completion handler for the ranged group of parallel operatations.
@@ -400,15 +400,15 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
 template <typename Handler, typename Op, typename Allocator>
 struct ranged_parallel_group_completion_handler
 {
-  typedef typename decay<
-      typename prefer_result<
-        typename associated_executor<Handler>::type,
+  typedef decay_t<
+      prefer_result_t<
+        associated_executor_t<Handler>,
         execution::outstanding_work_t::tracked_t
-      >::type
-    >::type executor_type;
+      >
+    > executor_type;
 
   typedef typename parallel_op_signature_as_tuple<
-      typename completion_signature_of<Op>::type
+      completion_signature_of_t<Op>
     >::type op_tuple_type;
 
   typedef parallel_group_op_result<op_tuple_type> op_result_type;
@@ -446,7 +446,7 @@ struct ranged_parallel_group_completion_handler
   {
     typedef typename parallel_op_signature_as_tuple<
         typename ranged_parallel_group_signature<
-          typename completion_signature_of<Op>::type,
+          completion_signature_of_t<Op>,
           Allocator
         >::raw_type
       >::type vectors_type;
@@ -474,7 +474,8 @@ struct ranged_parallel_group_completion_handler
       (void)pushback_fold;
     }
 
-    std::move(handler_)(completion_order_, std::move(std::get<I>(vectors))...);
+    std::move(handler_)(std::move(completion_order_),
+        std::move(std::get<I>(vectors))...);
   }
 
   Handler handler_;
@@ -544,7 +545,7 @@ struct ranged_parallel_group_op_handler
 
   ranged_parallel_group_op_handler(
       std::shared_ptr<ranged_parallel_group_state<
-        Condition, Handler, Op, Allocator> > state,
+        Condition, Handler, Op, Allocator>> state,
       std::size_t idx)
     : state_(std::move(state)),
       idx_(idx)
@@ -588,7 +589,7 @@ struct ranged_parallel_group_op_handler
   }
 
   std::shared_ptr<ranged_parallel_group_state<
-    Condition, Handler, Op, Allocator> > state_;
+    Condition, Handler, Op, Allocator>> state_;
   std::size_t idx_;
 };
 
@@ -606,7 +607,7 @@ struct ranged_parallel_group_op_handler_with_executor :
 
   ranged_parallel_group_op_handler_with_executor(
       std::shared_ptr<ranged_parallel_group_state<
-        Condition, Handler, Op, Allocator> > state,
+        Condition, Handler, Op, Allocator>> state,
       executor_type ex, std::size_t idx)
     : ranged_parallel_group_op_handler<Condition, Handler, Op, Allocator>(
         std::move(state), idx)
@@ -631,7 +632,7 @@ struct ranged_parallel_group_op_handler_with_executor :
   {
     cancel_proxy(
         std::shared_ptr<ranged_parallel_group_state<
-          Condition, Handler, Op, Allocator> > state,
+          Condition, Handler, Op, Allocator>> state,
         executor_type ex)
       : state_(std::move(state)),
         executor_(std::move(ex))
@@ -649,7 +650,7 @@ struct ranged_parallel_group_op_handler_with_executor :
     }
 
     std::weak_ptr<ranged_parallel_group_state<
-      Condition, Handler, Op, Allocator> > state_;
+      Condition, Handler, Op, Allocator>> state_;
     boost::asio::cancellation_signal signal_;
     executor_type executor_;
   };
@@ -662,7 +663,7 @@ struct ranged_parallel_group_cancellation_handler
 {
   ranged_parallel_group_cancellation_handler(
       std::shared_ptr<ranged_parallel_group_state<
-        Condition, Handler, Op, Allocator> > state)
+        Condition, Handler, Op, Allocator>> state)
     : state_(std::move(state))
   {
   }
@@ -680,7 +681,7 @@ struct ranged_parallel_group_cancellation_handler
   }
 
   std::weak_ptr<ranged_parallel_group_state<
-    Condition, Handler, Op, Allocator> > state_;
+    Condition, Handler, Op, Allocator>> state_;
 };
 
 template <typename Condition, typename Handler,
@@ -690,12 +691,11 @@ void ranged_parallel_group_launch(Condition cancellation_condition,
 {
   // Get the user's completion handler's cancellation slot, so that we can allow
   // cancellation of the entire group.
-  typename associated_cancellation_slot<Handler>::type slot
-          = boost::asio::get_associated_cancellation_slot(handler);
+  associated_cancellation_slot_t<Handler> slot
+    = boost::asio::get_associated_cancellation_slot(handler);
 
   // The type of the asynchronous operation.
-  typedef typename std::decay<decltype(
-      *std::declval<typename Range::iterator>())>::type op_type;
+  typedef decay_t<decltype(*declval<typename Range::iterator>())> op_type;
 
   // Create the shared state for the operation.
   typedef ranged_parallel_group_state<Condition,
@@ -709,7 +709,7 @@ void ranged_parallel_group_launch(Condition cancellation_condition,
   std::size_t idx = 0;
   for (auto&& op : std::forward<Range>(range))
   {
-    typedef typename associated_executor<op_type>::type ex_type;
+    typedef associated_executor_t<op_type> ex_type;
     ex_type ex = boost::asio::get_associated_executor(op);
     std::move(op)(
         ranged_parallel_group_op_handler_with_executor<
@@ -727,7 +727,7 @@ void ranged_parallel_group_launch(Condition cancellation_condition,
   if (slot.is_connected())
     slot.template emplace<
       ranged_parallel_group_cancellation_handler<
-        Condition, Handler, op_type, Allocator> >(state);
+        Condition, Handler, op_type, Allocator>>(state);
 }
 
 } // namespace detail
@@ -740,20 +740,18 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type
-  get(const experimental::detail::parallel_group_completion_handler<
-        Handler, Ops...>& h) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::parallel_group_completion_handler<
+        Handler, Ops...>& 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::parallel_group_completion_handler<
+  static auto get(
+      const experimental::detail::parallel_group_completion_handler<
         Handler, Ops...>& h,
-      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
-      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c))
   {
     return Associator<Handler, DefaultCandidate>::get(h.handler_, c);
   }
@@ -767,20 +765,18 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<Handler, DefaultCandidate>
 {
-  static typename Associator<Handler, DefaultCandidate>::type
-  get(const experimental::detail::ranged_parallel_group_completion_handler<
-        Handler, Op, Allocator>& h) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const experimental::detail::ranged_parallel_group_completion_handler<
+        Handler, Op, Allocator>& 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::ranged_parallel_group_completion_handler<
+  static auto get(
+      const experimental::detail::ranged_parallel_group_completion_handler<
         Handler, Op, Allocator>& h,
-      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
-      Associator<Handler, DefaultCandidate>::get(h.handler_, c)))
+      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/promise.hpp

@@ -18,6 +18,8 @@
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/cancellation_signal.hpp>
 #include <boost/asio/detail/utility.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/system/system_error.hpp>
 #include <tuple>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -57,8 +59,7 @@ struct promise_impl<void(Ts...), Executor, Allocator>
       reinterpret_cast<result_type*>(&result)->~result_type();
   }
 
-  typename aligned_storage<sizeof(result_type),
-    alignof(result_type)>::type result;
+  aligned_storage_t<sizeof(result_type), alignof(result_type)> result;
   std::atomic<bool> done{false};
   cancellation_signal cancel;
   Allocator allocator;

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

@@ -45,11 +45,11 @@ struct async_result<experimental::use_promise_t<Allocator>, R(Args...)>
   template <typename Initiation, typename... InitArgs>
   static auto initiate(Initiation initiation,
       experimental::use_promise_t<Allocator> up, InitArgs... args)
-    -> experimental::promise<void(typename decay<Args>::type...),
+    -> experimental::promise<void(decay_t<Args>...),
       boost::asio::associated_executor_t<Initiation>, Allocator>
   {
     using handler_type = experimental::detail::promise_handler<
-      void(typename decay<Args>::type...),
+      void(decay_t<Args>...),
       boost::asio::associated_executor_t<Initiation>, Allocator>;
 
     handler_type ht{up.get_allocator(), get_associated_executor(initiation)};

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

@@ -2,7 +2,7 @@
 // experimental/parallel_group.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)
@@ -17,8 +17,10 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <vector>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/array.hpp>
 #include <boost/asio/detail/memory.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/detail/utility.hpp>
 #include <boost/asio/experimental/cancellation_condition.hpp>
 
@@ -37,7 +39,7 @@ struct parallel_op_signature_as_tuple;
 template <typename R, typename... Args>
 struct parallel_op_signature_as_tuple<R(Args...)>
 {
-  typedef std::tuple<typename decay<Args>::type...> type;
+  typedef std::tuple<decay_t<Args>...> type;
 };
 
 // Helper trait for concatenating completion signatures.
@@ -163,7 +165,7 @@ public:
 
   /// The completion signature for the group of operations.
   typedef typename detail::parallel_group_signature<sizeof...(Ops),
-      typename completion_signature_of<Ops>::type...>::type signature;
+      completion_signature_of_t<Ops>...>::type signature;
 
   /// Initiate an asynchronous wait for the group of operations.
   /**
@@ -189,13 +191,12 @@ public:
    */
   template <typename CancellationCondition,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken, signature)
-  async_wait(CancellationCondition cancellation_condition,
+  auto async_wait(CancellationCondition cancellation_condition,
       CompletionToken&& token)
-    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    -> decltype(
       boost::asio::async_initiate<CompletionToken, signature>(
-          declval<initiate_async_wait>(), token,
-          std::move(cancellation_condition), std::move(ops_))))
+        declval<initiate_async_wait>(), token,
+        std::move(cancellation_condition), std::move(ops_)))
   {
     return boost::asio::async_initiate<CompletionToken, signature>(
         initiate_async_wait(), token,
@@ -253,7 +254,7 @@ make_parallel_group(Ops... ops)
  * See the documentation for boost::asio::experimental::make_parallel_group for
  * a usage example.
  */
-template <typename Range, typename Allocator = std::allocator<void> >
+template <typename Range, typename Allocator = std::allocator<void>>
 class ranged_parallel_group
 {
 private:
@@ -282,9 +283,8 @@ public:
 
   /// The completion signature for the group of operations.
   typedef typename detail::ranged_parallel_group_signature<
-      typename completion_signature_of<
-        typename std::decay<
-          decltype(*std::declval<typename Range::iterator>())>::type>::type,
+      completion_signature_of_t<
+        decay_t<decltype(*std::declval<typename Range::iterator>())>>,
       Allocator>::type signature;
 
   /// Initiate an asynchronous wait for the group of operations.
@@ -312,14 +312,13 @@ public:
    */
   template <typename CancellationCondition,
       BOOST_ASIO_COMPLETION_TOKEN_FOR(signature) CompletionToken>
-  BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken, signature)
-  async_wait(CancellationCondition cancellation_condition,
+  auto async_wait(CancellationCondition cancellation_condition,
       CompletionToken&& token)
-    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+    -> decltype(
       boost::asio::async_initiate<CompletionToken, signature>(
-          declval<initiate_async_wait>(), token,
-          std::move(cancellation_condition),
-          std::move(range_), allocator_)))
+        declval<initiate_async_wait>(), token,
+        std::move(cancellation_condition),
+        std::move(range_), allocator_))
   {
     return boost::asio::async_initiate<CompletionToken, signature>(
         initiate_async_wait(), token,
@@ -376,15 +375,13 @@ public:
  * @endcode
  */
 template <typename Range>
-BOOST_ASIO_NODISCARD inline
-ranged_parallel_group<typename std::decay<Range>::type>
+BOOST_ASIO_NODISCARD inline ranged_parallel_group<decay_t<Range>>
 make_parallel_group(Range&& range,
-    typename constraint<
-      is_async_operation_range<typename std::decay<Range>::type>::value
-    >::type = 0)
+    constraint_t<
+      is_async_operation_range<decay_t<Range>>::value
+    > = 0)
 {
-  return ranged_parallel_group<typename std::decay<Range>::type>(
-      std::forward<Range>(range));
+  return ranged_parallel_group<decay_t<Range>>(std::forward<Range>(range));
 }
 
 /// Create a group of operations that may be launched in parallel.
@@ -441,14 +438,13 @@ make_parallel_group(Range&& range,
  * @endcode
  */
 template <typename Allocator, typename Range>
-BOOST_ASIO_NODISCARD inline
-ranged_parallel_group<typename std::decay<Range>::type, Allocator>
+BOOST_ASIO_NODISCARD inline ranged_parallel_group<decay_t<Range>, Allocator>
 make_parallel_group(allocator_arg_t, const Allocator& allocator, Range&& range,
-    typename constraint<
-      is_async_operation_range<typename std::decay<Range>::type>::value
-    >::type = 0)
+    constraint_t<
+      is_async_operation_range<decay_t<Range>>::value
+    > = 0)
 {
-  return ranged_parallel_group<typename std::decay<Range>::type, Allocator>(
+  return ranged_parallel_group<decay_t<Range>, Allocator>(
       std::forward<Range>(range), allocator);
 }
 

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

@@ -2,7 +2,7 @@
 // experimental/prepend.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)

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

@@ -60,7 +60,7 @@ struct use_coro_t
   typedef Allocator allocator_type;
 
   /// Default constructor.
-  BOOST_ASIO_CONSTEXPR use_coro_t(
+  constexpr use_coro_t(
       allocator_type allocator = allocator_type{}
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
@@ -99,7 +99,7 @@ struct use_coro_t
   }
 
   /// Constructor used to specify file name, line, and function name.
-  BOOST_ASIO_CONSTEXPR use_coro_t(const char* file_name,
+  constexpr use_coro_t(const char* file_name,
       int line, const char* function_name,
       allocator_type allocator = allocator_type{}) :
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
@@ -127,13 +127,13 @@ struct use_coro_t
     /// Construct the adapted executor from the inner executor type.
     template <typename InnerExecutor1>
     executor_with_default(const InnerExecutor1& ex,
-        typename constraint<
-          conditional<
+        constraint_t<
+          conditional_t<
             !is_same<InnerExecutor1, executor_with_default>::value,
             is_convertible<InnerExecutor1, InnerExecutor>,
             false_type
-          >::type::value
-        >::type = 0) BOOST_ASIO_NOEXCEPT
+          >::value
+        > = 0) noexcept
       : InnerExecutor(ex)
     {
     }
@@ -141,25 +141,21 @@ struct use_coro_t
 
   /// Type alias to adapt an I/O object to use @c use_coro_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)
+      executor_with_default<typename T::executor_type>>::other;
 
   /// Function helper to adapt an I/O object to use @c use_coro_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>
+  static typename decay_t<T>::template rebind_executor<
+      executor_with_default<typename decay_t<T>::executor_type>
     >::other
-  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  as_default_on(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));
+    return typename decay_t<T>::template rebind_executor<
+        executor_with_default<typename decay_t<T>::executor_type>
+      >::other(static_cast<T&&>(object));
   }
 
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
@@ -179,10 +175,8 @@ private:
  */
 #if defined(GENERATING_DOCUMENTATION)
 constexpr use_coro_t<> use_coro;
-#elif defined(BOOST_ASIO_HAS_CONSTEXPR)
+#else
 constexpr use_coro_t<> use_coro(0, 0, 0);
-#elif defined(BOOST_ASIO_MSVC)
-__declspec(selectany) use_coro_t<> use_coro(0, 0, 0);
 #endif
 
 } // namespace experimental

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

@@ -34,7 +34,7 @@ struct use_promise_t
   typedef Allocator allocator_type;
 
   /// Construct using default-constructed allocator.
-  BOOST_ASIO_CONSTEXPR use_promise_t()
+  constexpr use_promise_t()
   {
   }
 
@@ -45,7 +45,7 @@ struct use_promise_t
   }
 
   /// Obtain allocator.
-  allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT
+  allocator_type get_allocator() const noexcept
   {
     return allocator_;
   }
@@ -59,7 +59,7 @@ struct use_promise_t
     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
+    executor_with_default(const InnerExecutor& ex) noexcept
       : InnerExecutor(ex)
     {
     }
@@ -68,9 +68,9 @@ struct use_promise_t
     /// that to construct the adapted executor.
     template <typename OtherExecutor>
     executor_with_default(const OtherExecutor& ex,
-        typename constraint<
+        constraint_t<
           is_convertible<OtherExecutor, InnerExecutor>::value
-        >::type = 0) BOOST_ASIO_NOEXCEPT
+        > = 0) noexcept
       : InnerExecutor(ex)
     {
     }
@@ -79,14 +79,14 @@ struct use_promise_t
   /// 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>
+  static typename decay_t<T>::template rebind_executor<
+      executor_with_default<typename decay_t<T>::executor_type>
     >::other
-  as_default_on(BOOST_ASIO_MOVE_ARG(T) object)
+  as_default_on(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));
+    return typename decay_t<T>::template rebind_executor<
+        executor_with_default<typename decay_t<T>::executor_type>
+      >::other(static_cast<T&&>(object));
   }
 
   /// Specify an alternate allocator.

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

@@ -2,7 +2,7 @@
 // file_base.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)