passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // impl/as_tuple.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>
 
@@ -42,53 +37,27 @@ public:
 
   template <typename CompletionToken>
   as_tuple_handler(as_tuple_t<CompletionToken> e)
-    : handler_(BOOST_ASIO_MOVE_CAST(CompletionToken)(e.token_))
+    : handler_(static_cast<CompletionToken&&>(e.token_))
   {
   }
 
   template <typename RedirectedHandler>
-  as_tuple_handler(BOOST_ASIO_MOVE_ARG(RedirectedHandler) h)
-    : handler_(BOOST_ASIO_MOVE_CAST(RedirectedHandler)(h))
+  as_tuple_handler(RedirectedHandler&& h)
+    : handler_(static_cast<RedirectedHandler&&>(h))
   {
   }
 
   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_tuple_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_tuple_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_tuple_handler<Handler>* this_handler)
@@ -97,75 +66,48 @@ 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_tuple_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_tuple_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_tuple_signature;
 
 template <typename R, typename... Args>
 struct as_tuple_signature<R(Args...)>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>);
+  typedef R type(std::tuple<decay_t<Args>...>);
 };
 
-#if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
-
 template <typename R, typename... Args>
 struct as_tuple_signature<R(Args...) &>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>) &;
+  typedef R type(std::tuple<decay_t<Args>...>) &;
 };
 
 template <typename R, typename... Args>
 struct as_tuple_signature<R(Args...) &&>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>) &&;
+  typedef R type(std::tuple<decay_t<Args>...>) &&;
 };
 
-# if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
+#if defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
 
 template <typename R, typename... Args>
 struct as_tuple_signature<R(Args...) noexcept>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>) noexcept;
+  typedef R type(std::tuple<decay_t<Args>...>) noexcept;
 };
 
 template <typename R, typename... Args>
 struct as_tuple_signature<R(Args...) & noexcept>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>) & noexcept;
+  typedef R type(std::tuple<decay_t<Args>...>) & noexcept;
 };
 
 template <typename R, typename... Args>
 struct as_tuple_signature<R(Args...) && noexcept>
 {
-  typedef R type(std::tuple<typename decay<Args>::type...>) && noexcept;
+  typedef R type(std::tuple<decay_t<Args>...>) && noexcept;
 };
 
-# endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
-#endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS)
+#endif // defined(BOOST_ASIO_HAS_NOEXCEPT_FUNCTION_TYPE)
 
 } // namespace detail
 
@@ -180,50 +122,43 @@ struct async_result<as_tuple_t<CompletionToken>, Signatures...>
   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_)(
-          detail::as_tuple_handler<
-            typename decay<Handler>::type>(
-              BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      static_cast<Initiation&&>(initiation_)(
+          detail::as_tuple_handler<decay_t<Handler>>(
+            static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-      typename detail::as_tuple_signature<Signatures>::type...)
-  initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
-      BOOST_ASIO_MOVE_ARG(Args)... args)
-    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
+    -> decltype(
       async_initiate<
-        typename conditional<
-          is_const<typename remove_reference<RawCompletionToken>::type>::value,
-            const CompletionToken, CompletionToken>::type,
+        conditional_t<
+          is_const<remove_reference_t<RawCompletionToken>>::value,
+            const CompletionToken, CompletionToken>,
         typename detail::as_tuple_signature<Signatures>::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)...))
   {
     return async_initiate<
-      typename conditional<
-        is_const<typename remove_reference<RawCompletionToken>::type>::value,
-          const CompletionToken, CompletionToken>::type,
+      conditional_t<
+        is_const<remove_reference_t<RawCompletionToken>>::value,
+          const CompletionToken, CompletionToken>,
       typename detail::as_tuple_signature<Signatures>::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)...);
   }
 };
 
@@ -240,50 +175,43 @@ struct async_result<as_tuple_t<CompletionToken>, Signature>
   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_)(
-          detail::as_tuple_handler<
-            typename decay<Handler>::type>(
-              BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      static_cast<Initiation&&>(initiation_)(
+          detail::as_tuple_handler<decay_t<Handler>>(
+            static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     Initiation initiation_;
   };
 
   template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_PREFIX(CompletionToken,
-      typename detail::as_tuple_signature<Signatures>::type...)
-  initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token,
-      BOOST_ASIO_MOVE_ARG(Args)... args)
-    BOOST_ASIO_INITFN_AUTO_RESULT_TYPE_SUFFIX((
+  static auto initiate(Initiation&& initiation,
+      RawCompletionToken&& token, Args&&... args)
+    -> decltype(
       async_initiate<
-        typename conditional<
-          is_const<typename remove_reference<RawCompletionToken>::type>::value,
-            const CompletionToken, CompletionToken>::type,
+        conditional_t<
+          is_const<remove_reference_t<RawCompletionToken>>::value,
+            const CompletionToken, CompletionToken>,
         typename detail::as_tuple_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)...))
   {
     return async_initiate<
-      typename conditional<
-        is_const<typename remove_reference<RawCompletionToken>::type>::value,
-          const CompletionToken, CompletionToken>::type,
+      conditional_t<
+        is_const<remove_reference_t<RawCompletionToken>>::value,
+          const CompletionToken, CompletionToken>,
       typename detail::as_tuple_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)...);
   }
 };
 
@@ -295,18 +223,15 @@ 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) BOOST_ASIO_NOEXCEPT
+  static typename Associator<Handler, DefaultCandidate>::type get(
+      const detail::as_tuple_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 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)))
+  static auto get(const detail::as_tuple_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/impl/awaitable.hpp

@@ -2,7 +2,7 @@
 // impl/awaitable.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)
@@ -176,7 +176,7 @@ public:
 
   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 defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
       , detail::source_location location = detail::source_location::current()
@@ -188,8 +188,8 @@ public:
       if (!!attached_thread_->get_cancellation_state().cancelled())
         throw_error(boost::asio::error::operation_aborted, "co_await");
 
-    return awaitable_async_op<typename completion_signature_of<Op>::type,
-      typename decay<Op>::type, Executor>{
+    return awaitable_async_op<
+      completion_signature_of_t<Op>, decay_t<Op>, Executor>{
         std::forward<Op>(op), this
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 # if defined(BOOST_ASIO_HAS_SOURCE_LOCATION)
@@ -298,11 +298,11 @@ public:
       auto await_resume()
       {
         return this_->attached_thread_->reset_cancellation_state(
-            BOOST_ASIO_MOVE_CAST(Filter)(filter_));
+            static_cast<Filter&&>(filter_));
       }
     };
 
-    return result{this, BOOST_ASIO_MOVE_CAST(Filter)(reset.filter)};
+    return result{this, static_cast<Filter&&>(reset.filter)};
   }
 
   // This await transformation resets the associated cancellation state.
@@ -329,14 +329,14 @@ public:
       auto await_resume()
       {
         return this_->attached_thread_->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{this,
-        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
@@ -400,12 +400,12 @@ public:
   // race condition.
   template <typename Function>
   auto await_transform(Function f,
-      typename enable_if<
+      enable_if_t<
         is_convertible<
-          typename result_of<Function(awaitable_frame_base*)>::type,
+          result_of_t<Function(awaitable_frame_base*)>,
           awaitable_thread<Executor>*
         >::value
-      >::type* = nullptr)
+      >* = nullptr)
   {
     struct result
     {
@@ -539,7 +539,7 @@ public:
   ~awaitable_frame()
   {
     if (has_result_)
-      static_cast<T*>(static_cast<void*>(result_))->~T();
+      std::launder(static_cast<T*>(static_cast<void*>(result_)))->~T();
   }
 
   awaitable<T, Executor> get_return_object() noexcept
@@ -565,7 +565,8 @@ public:
   {
     this->caller_ = nullptr;
     this->rethrow_exception();
-    return std::move(*static_cast<T*>(static_cast<void*>(result_)));
+    return std::move(*std::launder(
+          static_cast<T*>(static_cast<void*>(result_))));
   }
 
 private:
@@ -719,21 +720,21 @@ public:
   }
 
   template <typename Filter>
-  void reset_cancellation_state(BOOST_ASIO_MOVE_ARG(Filter) filter)
+  void reset_cancellation_state(Filter&& filter)
   {
     bottom_of_stack_.frame_->cancellation_state_ =
       cancellation_state(bottom_of_stack_.frame_->parent_cancellation_slot_,
-        BOOST_ASIO_MOVE_CAST(Filter)(filter));
+        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)
   {
     bottom_of_stack_.frame_->cancellation_state_ =
       cancellation_state(bottom_of_stack_.frame_->parent_cancellation_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