passenger 6.0.20 → 6.0.21

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

@@ -2,7 +2,7 @@
 // bind_cancellation_slot.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,7 +17,6 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/type_traits.hpp>
-#include <boost/asio/detail/variadic_templates.hpp>
 #include <boost/asio/associated_cancellation_slot.hpp>
 #include <boost/asio/associator.hpp>
 #include <boost/asio/async_result.hpp>
@@ -38,8 +37,7 @@ protected:
 };
 
 template <typename T>
-struct cancellation_slot_binder_result_type<T,
-  typename void_type<typename T::result_type>::type>
+struct cancellation_slot_binder_result_type<T, void_t<typename T::result_type>>
 {
   typedef typename T::result_type result_type;
 protected:
@@ -101,7 +99,7 @@ struct cancellation_slot_binder_argument_type {};
 
 template <typename T>
 struct cancellation_slot_binder_argument_type<T,
-  typename void_type<typename T::argument_type>::type>
+    void_t<typename T::argument_type>>
 {
   typedef typename T::argument_type argument_type;
 };
@@ -126,7 +124,7 @@ struct cancellation_slot_binder_argument_types {};
 
 template <typename T>
 struct cancellation_slot_binder_argument_types<T,
-  typename void_type<typename T::first_argument_type>::type>
+    void_t<typename T::first_argument_type>>
 {
   typedef typename T::first_argument_type first_argument_type;
   typedef typename T::second_argument_type second_argument_type;
@@ -146,21 +144,6 @@ struct cancellation_slot_binder_argument_type<R(&)(A1, A2)>
   typedef A2 second_argument_type;
 };
 
-// Helper to enable SFINAE on zero-argument operator() below.
-
-template <typename T, typename = void>
-struct cancellation_slot_binder_result_of0
-{
-  typedef void type;
-};
-
-template <typename T>
-struct cancellation_slot_binder_result_of0<T,
-  typename void_type<typename result_of<T()>::type>::type>
-{
-  typedef typename result_of<T()>::type type;
-};
-
 } // namespace detail
 
 /// A call wrapper type to bind a cancellation slot of type @c CancellationSlot
@@ -248,10 +231,9 @@ public:
    * @c U.
    */
   template <typename U>
-  cancellation_slot_binder(const cancellation_slot_type& s,
-      BOOST_ASIO_MOVE_ARG(U) u)
+  cancellation_slot_binder(const cancellation_slot_type& s, U&& u)
     : slot_(s),
-      target_(BOOST_ASIO_MOVE_CAST(U)(u))
+      target_(static_cast<U&&>(u))
   {
   }
 
@@ -278,7 +260,10 @@ public:
    */
   template <typename U, typename OtherCancellationSlot>
   cancellation_slot_binder(
-      const cancellation_slot_binder<U, OtherCancellationSlot>& other)
+      const cancellation_slot_binder<U, OtherCancellationSlot>& other,
+      constraint_t<is_constructible<CancellationSlot,
+        OtherCancellationSlot>::value> = 0,
+      constraint_t<is_constructible<T, U>::value> = 0)
     : slot_(other.get_cancellation_slot()),
       target_(other.get())
   {
@@ -292,19 +277,18 @@ public:
    */
   template <typename U, typename OtherCancellationSlot>
   cancellation_slot_binder(const cancellation_slot_type& s,
-      const cancellation_slot_binder<U, OtherCancellationSlot>& other)
+      const cancellation_slot_binder<U, OtherCancellationSlot>& other,
+      constraint_t<is_constructible<T, U>::value> = 0)
     : slot_(s),
       target_(other.get())
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Move constructor.
   cancellation_slot_binder(cancellation_slot_binder&& other)
-    : slot_(BOOST_ASIO_MOVE_CAST(cancellation_slot_type)(
+    : slot_(static_cast<cancellation_slot_type&&>(
           other.get_cancellation_slot())),
-      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+      target_(static_cast<T&&>(other.get()))
   {
   }
 
@@ -313,17 +297,20 @@ public:
   cancellation_slot_binder(const cancellation_slot_type& s,
       cancellation_slot_binder&& other)
     : slot_(s),
-      target_(BOOST_ASIO_MOVE_CAST(T)(other.get()))
+      target_(static_cast<T&&>(other.get()))
   {
   }
 
   /// Move construct from a different cancellation slot wrapper type.
   template <typename U, typename OtherCancellationSlot>
   cancellation_slot_binder(
-      cancellation_slot_binder<U, OtherCancellationSlot>&& other)
-    : slot_(BOOST_ASIO_MOVE_CAST(OtherCancellationSlot)(
+      cancellation_slot_binder<U, OtherCancellationSlot>&& other,
+      constraint_t<is_constructible<CancellationSlot,
+        OtherCancellationSlot>::value> = 0,
+      constraint_t<is_constructible<T, U>::value> = 0)
+    : slot_(static_cast<OtherCancellationSlot&&>(
           other.get_cancellation_slot())),
-      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+      target_(static_cast<U&&>(other.get()))
   {
   }
 
@@ -331,126 +318,50 @@ public:
   /// specify a different cancellation slot.
   template <typename U, typename OtherCancellationSlot>
   cancellation_slot_binder(const cancellation_slot_type& s,
-      cancellation_slot_binder<U, OtherCancellationSlot>&& other)
+      cancellation_slot_binder<U, OtherCancellationSlot>&& other,
+      constraint_t<is_constructible<T, U>::value> = 0)
     : slot_(s),
-      target_(BOOST_ASIO_MOVE_CAST(U)(other.get()))
+      target_(static_cast<U&&>(other.get()))
   {
   }
 
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Destructor.
   ~cancellation_slot_binder()
   {
   }
 
   /// Obtain a reference to the target object.
-  target_type& get() BOOST_ASIO_NOEXCEPT
+  target_type& get() noexcept
   {
     return target_;
   }
 
   /// Obtain a reference to the target object.
-  const target_type& get() const BOOST_ASIO_NOEXCEPT
+  const target_type& get() const noexcept
   {
     return target_;
   }
 
   /// Obtain the associated cancellation slot.
-  cancellation_slot_type get_cancellation_slot() const BOOST_ASIO_NOEXCEPT
+  cancellation_slot_type get_cancellation_slot() const noexcept
   {
     return slot_;
   }
 
-#if defined(GENERATING_DOCUMENTATION)
-
-  template <typename... Args> auto operator()(Args&& ...);
-  template <typename... Args> auto operator()(Args&& ...) const;
-
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
   /// Forwarding function call operator.
   template <typename... Args>
-  typename result_of<T(Args...)>::type operator()(
-      BOOST_ASIO_MOVE_ARG(Args)... args)
+  result_of_t<T(Args...)> operator()(Args&&... args)
   {
-    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
+    return target_(static_cast<Args&&>(args)...);
   }
 
   /// Forwarding function call operator.
   template <typename... Args>
-  typename result_of<T(Args...)>::type operator()(
-      BOOST_ASIO_MOVE_ARG(Args)... args) const
-  {
-    return target_(BOOST_ASIO_MOVE_CAST(Args)(args)...);
-  }
-
-#elif defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
-
-  typename detail::cancellation_slot_binder_result_of0<T>::type operator()()
-  {
-    return target_();
-  }
-
-  typename detail::cancellation_slot_binder_result_of0<T>::type
-  operator()() const
-  {
-    return target_();
-  }
-
-#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  typename result_of<T(BOOST_ASIO_VARIADIC_TARGS(n))>::type operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
-#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
-
-#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
-
-  typedef typename detail::cancellation_slot_binder_result_type<
-    T>::result_type_or_void result_type_or_void;
-
-  result_type_or_void operator()()
-  {
-    return target_();
-  }
-
-  result_type_or_void operator()() const
+  result_of_t<T(Args...)> operator()(Args&&... args) const
   {
-    return target_();
+    return target_(static_cast<Args&&>(args)...);
   }
 
-#define BOOST_ASIO_PRIVATE_BINDER_CALL_DEF(n) \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  result_type_or_void operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  result_type_or_void operator()( \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
-  { \
-    return target_(BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_BINDER_CALL_DEF)
-#undef BOOST_ASIO_PRIVATE_BINDER_CALL_DEF
-
-#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
-
 private:
   CancellationSlot slot_;
   T target_;
@@ -460,12 +371,11 @@ private:
 /// @c CancellationSlot.
 template <typename CancellationSlot, typename T>
 BOOST_ASIO_NODISCARD inline
-cancellation_slot_binder<typename decay<T>::type, CancellationSlot>
-bind_cancellation_slot(const CancellationSlot& s, BOOST_ASIO_MOVE_ARG(T) t)
+cancellation_slot_binder<decay_t<T>, CancellationSlot>
+bind_cancellation_slot(const CancellationSlot& s, T&& t)
 {
-  return cancellation_slot_binder<
-    typename decay<T>::type, CancellationSlot>(
-      s, BOOST_ASIO_MOVE_CAST(T)(t));
+  return cancellation_slot_binder<decay_t<T>, CancellationSlot>(
+      s, static_cast<T&&>(t));
 }
 
 #if !defined(GENERATING_DOCUMENTATION)
@@ -473,7 +383,7 @@ bind_cancellation_slot(const CancellationSlot& s, BOOST_ASIO_MOVE_ARG(T) t)
 namespace detail {
 
 template <typename TargetAsyncResult,
-  typename CancellationSlot, typename = void>
+    typename CancellationSlot, typename = void>
 class cancellation_slot_binder_completion_handler_async_result
 {
 public:
@@ -485,11 +395,12 @@ public:
 
 template <typename TargetAsyncResult, typename CancellationSlot>
 class cancellation_slot_binder_completion_handler_async_result<
-  TargetAsyncResult, CancellationSlot,
-  typename void_type<
-    typename TargetAsyncResult::completion_handler_type
-  >::type>
+    TargetAsyncResult, CancellationSlot,
+    void_t<typename TargetAsyncResult::completion_handler_type>>
 {
+private:
+  TargetAsyncResult target_;
+
 public:
   typedef cancellation_slot_binder<
     typename TargetAsyncResult::completion_handler_type, CancellationSlot>
@@ -501,13 +412,10 @@ public:
   {
   }
 
-  typename TargetAsyncResult::return_type get()
+  auto get() -> decltype(target_.get())
   {
     return target_.get();
   }
-
-private:
-  TargetAsyncResult target_;
 };
 
 template <typename TargetAsyncResult, typename = void>
@@ -517,10 +425,7 @@ struct cancellation_slot_binder_async_result_return_type
 
 template <typename TargetAsyncResult>
 struct cancellation_slot_binder_async_result_return_type<
-  TargetAsyncResult,
-  typename void_type<
-    typename TargetAsyncResult::return_type
-  >::type>
+    TargetAsyncResult, void_t<typename TargetAsyncResult::return_type>>
 {
   typedef typename TargetAsyncResult::return_type return_type;
 };
@@ -530,9 +435,9 @@ struct cancellation_slot_binder_async_result_return_type<
 template <typename T, typename CancellationSlot, typename Signature>
 class async_result<cancellation_slot_binder<T, CancellationSlot>, Signature> :
   public detail::cancellation_slot_binder_completion_handler_async_result<
-    async_result<T, Signature>, CancellationSlot>,
+      async_result<T, Signature>, CancellationSlot>,
   public detail::cancellation_slot_binder_async_result_return_type<
-    async_result<T, Signature> >
+      async_result<T, Signature>>
 {
 public:
   explicit async_result(cancellation_slot_binder<T, CancellationSlot>& b)
@@ -545,160 +450,52 @@ public:
   struct init_wrapper
   {
     template <typename Init>
-    init_wrapper(const CancellationSlot& slot, BOOST_ASIO_MOVE_ARG(Init) init)
+    init_wrapper(const CancellationSlot& slot, Init&& init)
       : slot_(slot),
-        initiation_(BOOST_ASIO_MOVE_CAST(Init)(init))
+        initiation_(static_cast<Init&&>(init))
     {
     }
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
     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_)(
-          cancellation_slot_binder<
-            typename decay<Handler>::type, CancellationSlot>(
-              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
+      static_cast<Initiation&&>(initiation_)(
+          cancellation_slot_binder<decay_t<Handler>, CancellationSlot>(
+              slot_, static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
     template <typename Handler, typename... Args>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler,
-        BOOST_ASIO_MOVE_ARG(Args)... args) const
+    void operator()(Handler&& handler, Args&&... args) const
     {
       initiation_(
-          cancellation_slot_binder<
-            typename decay<Handler>::type, CancellationSlot>(
-              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-          BOOST_ASIO_MOVE_CAST(Args)(args)...);
-    }
-
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-    template <typename Handler>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler)
-    {
-      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)(
-          cancellation_slot_binder<
-            typename decay<Handler>::type, CancellationSlot>(
-              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
+          cancellation_slot_binder<decay_t<Handler>, CancellationSlot>(
+              slot_, static_cast<Handler&&>(handler)),
+          static_cast<Args&&>(args)...);
     }
 
-    template <typename Handler>
-    void operator()(
-        BOOST_ASIO_MOVE_ARG(Handler) handler) const
-    {
-      initiation_(
-          cancellation_slot_binder<
-            typename decay<Handler>::type, CancellationSlot>(
-              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)));
-    }
-
-#define BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
-    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-    void operator()( \
-        BOOST_ASIO_MOVE_ARG(Handler) handler, \
-        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-    { \
-      BOOST_ASIO_MOVE_CAST(Initiation)(initiation_)( \
-          cancellation_slot_binder< \
-            typename decay<Handler>::type, CancellationSlot>( \
-              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
-          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-    } \
-    \
-    template <typename Handler, BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-    void operator()( \
-        BOOST_ASIO_MOVE_ARG(Handler) handler, \
-        BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) const \
-    { \
-      initiation_( \
-          cancellation_slot_binder< \
-            typename decay<Handler>::type, CancellationSlot>( \
-              slot_, BOOST_ASIO_MOVE_CAST(Handler)(handler)), \
-          BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-    } \
-    /**/
-    BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF)
-#undef BOOST_ASIO_PRIVATE_INIT_WRAPPER_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
     CancellationSlot slot_;
     Initiation initiation_;
   };
 
-#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
   template <typename Initiation, typename RawCompletionToken, typename... Args>
-  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
-    (async_initiate<T, Signature>(
-        declval<init_wrapper<typename decay<Initiation>::type> >(),
-        declval<RawCompletionToken>().get(),
-        declval<BOOST_ASIO_MOVE_ARG(Args)>()...)))
-  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<T, Signature>(
+        declval<init_wrapper<decay_t<Initiation>>>(),
+        token.get(), static_cast<Args&&>(args)...))
   {
     return async_initiate<T, Signature>(
-        init_wrapper<typename decay<Initiation>::type>(
+        init_wrapper<decay_t<Initiation>>(
           token.get_cancellation_slot(),
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
-        token.get(), BOOST_ASIO_MOVE_CAST(Args)(args)...);
+          static_cast<Initiation&&>(initiation)),
+        token.get(), static_cast<Args&&>(args)...);
   }
 
-#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
-  template <typename Initiation, typename RawCompletionToken>
-  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
-    (async_initiate<T, Signature>(
-        declval<init_wrapper<typename decay<Initiation>::type> >(),
-        declval<RawCompletionToken>().get())))
-  initiate(
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation,
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token)
-  {
-    return async_initiate<T, Signature>(
-        init_wrapper<typename decay<Initiation>::type>(
-          token.get_cancellation_slot(),
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)),
-        token.get());
-  }
-
-#define BOOST_ASIO_PRIVATE_INITIATE_DEF(n) \
-  template <typename Initiation, typename RawCompletionToken, \
-      BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  static BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
-    (async_initiate<T, Signature>( \
-        declval<init_wrapper<typename decay<Initiation>::type> >(), \
-        declval<RawCompletionToken>().get(), \
-        BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
-  initiate( \
-      BOOST_ASIO_MOVE_ARG(Initiation) initiation, \
-      BOOST_ASIO_MOVE_ARG(RawCompletionToken) token, \
-      BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)) \
-  { \
-    return async_initiate<T, Signature>( \
-        init_wrapper<typename decay<Initiation>::type>( \
-          token.get_cancellation_slot(), \
-          BOOST_ASIO_MOVE_CAST(Initiation)(initiation)), \
-        token.get(), BOOST_ASIO_VARIADIC_MOVE_ARGS(n)); \
-  } \
-  /**/
-  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_INITIATE_DEF)
-#undef BOOST_ASIO_PRIVATE_INITIATE_DEF
-
-#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 private:
-  async_result(const async_result&) BOOST_ASIO_DELETED;
-  async_result& operator=(const async_result&) BOOST_ASIO_DELETED;
+  async_result(const async_result&) = delete;
+  async_result& operator=(const async_result&) = delete;
 
   async_result<T, Signature> target_;
 };
@@ -710,19 +507,15 @@ struct associator<Associator,
     DefaultCandidate>
   : Associator<T, DefaultCandidate>
 {
-  static typename Associator<T, DefaultCandidate>::type
-  get(const cancellation_slot_binder<T, CancellationSlot>& b)
-    BOOST_ASIO_NOEXCEPT
+  static typename Associator<T, DefaultCandidate>::type get(
+      const cancellation_slot_binder<T, CancellationSlot>& b) noexcept
   {
     return Associator<T, DefaultCandidate>::get(b.get());
   }
 
-  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX2(
-      typename Associator<T, DefaultCandidate>::type)
-  get(const cancellation_slot_binder<T, CancellationSlot>& b,
-      const DefaultCandidate& c) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((
-      Associator<T, DefaultCandidate>::get(b.get(), c)))
+  static auto get(const cancellation_slot_binder<T, CancellationSlot>& b,
+      const DefaultCandidate& c) noexcept
+    -> decltype(Associator<T, DefaultCandidate>::get(b.get(), c))
   {
     return Associator<T, DefaultCandidate>::get(b.get(), c);
   }
@@ -735,10 +528,9 @@ struct associated_cancellation_slot<
 {
   typedef CancellationSlot type;
 
-  static BOOST_ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(
-      const cancellation_slot_binder<T, CancellationSlot>& b,
-      const CancellationSlot1& = CancellationSlot1()) BOOST_ASIO_NOEXCEPT
-    BOOST_ASIO_AUTO_RETURN_TYPE_SUFFIX((b.get_cancellation_slot()))
+  static auto get(const cancellation_slot_binder<T, CancellationSlot>& b,
+      const CancellationSlot1& = CancellationSlot1()) noexcept
+    -> decltype(b.get_cancellation_slot())
   {
     return b.get_cancellation_slot();
   }