passenger 6.0.8 → 6.0.9

data/src/cxx_supportlib/vendor-modified/boost/asio/posix/basic_descriptor.hpp

@@ -2,7 +2,7 @@
 // posix/basic_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2021 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)
@@ -86,7 +86,7 @@ public:
    * descriptor.
    */
   explicit basic_descriptor(const executor_type& ex)
-    : impl_(ex)
+    : impl_(0, ex)
   {
   }
 
@@ -100,10 +100,11 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_descriptor(ExecutionContext& context,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
+    : impl_(0, 0, context)
   {
   }
 
@@ -122,7 +123,7 @@ public:
    */
   basic_descriptor(const executor_type& ex,
       const native_handle_type& native_descriptor)
-    : impl_(ex)
+    : impl_(0, ex)
   {
     boost::system::error_code ec;
     impl_.get_service().assign(impl_.get_implementation(),
@@ -146,10 +147,10 @@ public:
   template <typename ExecutionContext>
   basic_descriptor(ExecutionContext& context,
       const native_handle_type& native_descriptor,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
-    : impl_(context)
+      >::type = 0)
+    : impl_(0, 0, context)
   {
     boost::system::error_code ec;
     impl_.get_service().assign(impl_.get_implementation(),

data/src/cxx_supportlib/vendor-modified/boost/asio/posix/basic_stream_descriptor.hpp

@@ -2,7 +2,7 @@
 // posix/basic_stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2021 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)
@@ -21,6 +21,8 @@
 #if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
+#include <boost/asio/detail/push_options.hpp>
+
 namespace boost {
 namespace asio {
 namespace posix {
@@ -34,6 +36,12 @@ namespace posix {
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
+ * Synchronous @c read_some and @c write_some operations are thread safe with
+ * respect to each other, if the underlying operating system calls are also
+ * thread safe. This means that it is permitted to perform concurrent calls to
+ * these synchronous operations on a single descriptor object. Other synchronous
+ * operations, such as @c close, are not thread safe.
+ *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
@@ -84,9 +92,10 @@ public:
    */
   template <typename ExecutionContext>
   explicit basic_stream_descriptor(ExecutionContext& context,
-      typename enable_if<
-        is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      typename constraint<
+        is_convertible<ExecutionContext&, execution_context&>::value,
+        defaulted_constraint
+      >::type = defaulted_constraint())
     : basic_descriptor<Executor>(context)
   {
   }
@@ -126,9 +135,9 @@ public:
   template <typename ExecutionContext>
   basic_stream_descriptor(ExecutionContext& context,
       const native_handle_type& native_descriptor,
-      typename enable_if<
+      typename constraint<
         is_convertible<ExecutionContext&, execution_context&>::value
-      >::type* = 0)
+      >::type = 0)
     : basic_descriptor<Executor>(context, native_descriptor)
   {
   }
@@ -466,6 +475,8 @@ private:
 } // namespace asio
 } // namespace boost
 
+#include <boost/asio/detail/pop_options.hpp>
+
 #endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 

data/src/cxx_supportlib/vendor-modified/boost/asio/posix/descriptor.hpp

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

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

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

@@ -2,7 +2,7 @@
 // post.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2021 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)
@@ -98,9 +98,9 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
     const Executor& ex,
     BOOST_ASIO_MOVE_ARG(CompletionToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
-    typename enable_if<
+    typename constraint<
       execution::is_executor<Executor>::value || is_executor<Executor>::value
-    >::type* = 0);
+    >::type = 0);
 
 /// Submits a completion token or function object for execution.
 /**
@@ -115,8 +115,8 @@ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, void()) post(
     BOOST_ASIO_MOVE_ARG(CompletionToken) token
       BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(
         typename ExecutionContext::executor_type),
-    typename enable_if<is_convertible<
-      ExecutionContext&, execution_context&>::value>::type* = 0);
+    typename constraint<is_convertible<
+      ExecutionContext&, execution_context&>::value>::type = 0);
 
 } // namespace asio
 } // namespace boost

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

@@ -2,7 +2,7 @@
 // prefer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2021 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)
@@ -120,6 +120,7 @@ struct prefer_result
 
 namespace asio_prefer_fn {
 
+using boost::asio::conditional;
 using boost::asio::decay;
 using boost::asio::declval;
 using boost::asio::enable_if;
@@ -145,7 +146,9 @@ enum overload_type
   ill_formed
 };
 
-template <typename T, typename Properties, typename = void>
+template <typename Impl, typename T, typename Properties,
+    typename = void, typename = void, typename = void, typename = void,
+    typename = void, typename = void, typename = void>
 struct call_traits
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = ill_formed);
@@ -153,19 +156,19 @@ struct call_traits
   typedef void result_type;
 };
 
-template <typename T, typename Property>
-struct call_traits<T, void(Property),
+template <typename Impl, typename T, typename Property>
+struct call_traits<Impl, T, void(Property),
   typename enable_if<
-    (
-      is_applicable_property<
-        typename decay<T>::type,
-        typename decay<Property>::type
-      >::value
-      &&
-      decay<Property>::type::is_preferable
-      &&
-      static_require<T, Property>::is_valid
-    )
+    is_applicable_property<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value
+  >::type,
+  typename enable_if<
+    decay<Property>::type::is_preferable
+  >::type,
+  typename enable_if<
+    static_require<T, Property>::is_valid
   >::type>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
@@ -178,123 +181,137 @@ struct call_traits<T, void(Property),
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 };
 
-template <typename T, typename Property>
-struct call_traits<T, void(Property),
+template <typename Impl, typename T, typename Property>
+struct call_traits<Impl, T, void(Property),
   typename enable_if<
-    (
-      is_applicable_property<
-        typename decay<T>::type,
-        typename decay<Property>::type
-      >::value
-      &&
-      decay<Property>::type::is_preferable
-      &&
-      !static_require<T, Property>::is_valid
-      &&
-      require_member<T, Property>::is_valid
-    )
+    is_applicable_property<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value
+  >::type,
+  typename enable_if<
+    decay<Property>::type::is_preferable
+  >::type,
+  typename enable_if<
+    !static_require<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    require_member<typename Impl::template proxy<T>::type, Property>::is_valid
   >::type> :
-  require_member<T, Property>
+  require_member<typename Impl::template proxy<T>::type, Property>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_member);
 };
 
-template <typename T, typename Property>
-struct call_traits<T, void(Property),
+template <typename Impl, typename T, typename Property>
+struct call_traits<Impl, T, void(Property),
   typename enable_if<
-    (
-      is_applicable_property<
-        typename decay<T>::type,
-        typename decay<Property>::type
-      >::value
-      &&
-      decay<Property>::type::is_preferable
-      &&
-      !static_require<T, Property>::is_valid
-      &&
-      !require_member<T, Property>::is_valid
-      &&
-      require_free<T, Property>::is_valid
-    )
+    is_applicable_property<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value
+  >::type,
+  typename enable_if<
+    decay<Property>::type::is_preferable
+  >::type,
+  typename enable_if<
+    !static_require<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
+  >::type,
+  typename enable_if<
+    require_free<T, Property>::is_valid
   >::type> :
   require_free<T, Property>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_require_free);
 };
 
-template <typename T, typename Property>
-struct call_traits<T, void(Property),
+template <typename Impl, typename T, typename Property>
+struct call_traits<Impl, T, void(Property),
   typename enable_if<
-    (
-      is_applicable_property<
-        typename decay<T>::type,
-        typename decay<Property>::type
-      >::value
-      &&
-      decay<Property>::type::is_preferable
-      &&
-      !static_require<T, Property>::is_valid
-      &&
-      !require_member<T, Property>::is_valid
-      &&
-      !require_free<T, Property>::is_valid
-      &&
-      prefer_member<T, Property>::is_valid
-    )
+    is_applicable_property<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value
+  >::type,
+  typename enable_if<
+    decay<Property>::type::is_preferable
+  >::type,
+  typename enable_if<
+    !static_require<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_free<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
   >::type> :
-  prefer_member<T, Property>
+  prefer_member<typename Impl::template proxy<T>::type, Property>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_member);
 };
 
-template <typename T, typename Property>
-struct call_traits<T, void(Property),
+template <typename Impl, typename T, typename Property>
+struct call_traits<Impl, T, void(Property),
   typename enable_if<
-    (
-      is_applicable_property<
-        typename decay<T>::type,
-        typename decay<Property>::type
-      >::value
-      &&
-      decay<Property>::type::is_preferable
-      &&
-      !static_require<T, Property>::is_valid
-      &&
-      !require_member<T, Property>::is_valid
-      &&
-      !require_free<T, Property>::is_valid
-      &&
-      !prefer_member<T, Property>::is_valid
-      &&
-      prefer_free<T, Property>::is_valid
-    )
+    is_applicable_property<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value
+  >::type,
+  typename enable_if<
+    decay<Property>::type::is_preferable
+  >::type,
+  typename enable_if<
+    !static_require<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_free<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
+  >::type,
+  typename enable_if<
+    prefer_free<T, Property>::is_valid
   >::type> :
   prefer_free<T, Property>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = call_prefer_free);
 };
 
-template <typename T, typename Property>
-struct call_traits<T, void(Property),
+template <typename Impl, typename T, typename Property>
+struct call_traits<Impl, T, void(Property),
   typename enable_if<
-    (
-      is_applicable_property<
-        typename decay<T>::type,
-        typename decay<Property>::type
-      >::value
-      &&
-      decay<Property>::type::is_preferable
-      &&
-      !static_require<T, Property>::is_valid
-      &&
-      !require_member<T, Property>::is_valid
-      &&
-      !require_free<T, Property>::is_valid
-      &&
-      !prefer_member<T, Property>::is_valid
-      &&
-      !prefer_free<T, Property>::is_valid
-    )
+    is_applicable_property<
+      typename decay<T>::type,
+      typename decay<Property>::type
+    >::value
+  >::type,
+  typename enable_if<
+    decay<Property>::type::is_preferable
+  >::type,
+  typename enable_if<
+    !static_require<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_member<typename Impl::template proxy<T>::type, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !require_free<T, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !prefer_member<typename Impl::template proxy<T>::type, Property>::is_valid
+  >::type,
+  typename enable_if<
+    !prefer_free<T, Property>::is_valid
   >::type>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(overload_type, overload = identity);
@@ -307,13 +324,15 @@ struct call_traits<T, void(Property),
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 };
 
-template <typename T, typename P0, typename P1>
-struct call_traits<T, void(P0, P1),
+template <typename Impl, typename T, typename P0, typename P1>
+struct call_traits<Impl, T, void(P0, P1),
+  typename enable_if<
+    call_traits<Impl, T, void(P0)>::overload != ill_formed
+  >::type,
   typename enable_if<
-    call_traits<T, void(P0)>::overload != ill_formed
-    &&
     call_traits<
-      typename call_traits<T, void(P0)>::result_type,
+      Impl,
+      typename call_traits<Impl, T, void(P0)>::result_type,
       void(P1)
     >::overload != ill_formed
   >::type>
@@ -322,29 +341,34 @@ struct call_traits<T, void(P0, P1),
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
     (
-      call_traits<T, void(P0)>::is_noexcept
+      call_traits<Impl, T, void(P0)>::is_noexcept
       &&
       call_traits<
-        typename call_traits<T, void(P0)>::result_type,
+        Impl,
+        typename call_traits<Impl, T, void(P0)>::result_type,
         void(P1)
       >::is_noexcept
     ));
 
   typedef typename decay<
     typename call_traits<
-      typename call_traits<T, void(P0)>::result_type,
+      Impl,
+      typename call_traits<Impl, T, void(P0)>::result_type,
       void(P1)
     >::result_type
   >::type result_type;
 };
 
-template <typename T, typename P0, typename P1, typename BOOST_ASIO_ELLIPSIS PN>
-struct call_traits<T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS),
+template <typename Impl, typename T, typename P0,
+    typename P1, typename BOOST_ASIO_ELLIPSIS PN>
+struct call_traits<Impl, T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS),
+  typename enable_if<
+    call_traits<Impl, T, void(P0)>::overload != ill_formed
+  >::type,
   typename enable_if<
-    call_traits<T, void(P0)>::overload != ill_formed
-    &&
     call_traits<
-      typename call_traits<T, void(P0)>::result_type,
+      Impl,
+      typename call_traits<Impl, T, void(P0)>::result_type,
       void(P1, PN BOOST_ASIO_ELLIPSIS)
     >::overload != ill_formed
   >::type>
@@ -353,17 +377,19 @@ struct call_traits<T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS),
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept =
     (
-      call_traits<T, void(P0)>::is_noexcept
+      call_traits<Impl, T, void(P0)>::is_noexcept
       &&
       call_traits<
-        typename call_traits<T, void(P0)>::result_type,
+        Impl,
+        typename call_traits<Impl, T, void(P0)>::result_type,
         void(P1, PN BOOST_ASIO_ELLIPSIS)
       >::is_noexcept
     ));
 
   typedef typename decay<
     typename call_traits<
-      typename call_traits<T, void(P0)>::result_type,
+      Impl,
+      typename call_traits<Impl, T, void(P0)>::result_type,
       void(P1, PN BOOST_ASIO_ELLIPSIS)
     >::result_type
   >::type result_type;
@@ -371,30 +397,70 @@ struct call_traits<T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS),
 
 struct impl
 {
+  template <typename T>
+  struct proxy
+  {
+#if defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT) \
+  && defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+    struct type
+    {
+      template <typename P>
+      auto require(BOOST_ASIO_MOVE_ARG(P) p)
+        noexcept(
+          noexcept(
+            declval<typename conditional<true, T, P>::type>().require(
+              BOOST_ASIO_MOVE_CAST(P)(p))
+          )
+        )
+        -> decltype(
+          declval<typename conditional<true, T, P>::type>().require(
+            BOOST_ASIO_MOVE_CAST(P)(p))
+        );
+
+      template <typename P>
+      auto prefer(BOOST_ASIO_MOVE_ARG(P) p)
+        noexcept(
+          noexcept(
+            declval<typename conditional<true, T, P>::type>().prefer(
+              BOOST_ASIO_MOVE_CAST(P)(p))
+          )
+        )
+        -> decltype(
+          declval<typename conditional<true, T, P>::type>().prefer(
+            BOOST_ASIO_MOVE_CAST(P)(p))
+        );
+    };
+#else // defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
+      //   && defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+    typedef T type;
+#endif // defined(BOOST_ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
+       //   && defined(BOOST_ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
+  };
+
   template <typename T, typename Property>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(Property)>::overload == identity,
-    typename call_traits<T, void(Property)>::result_type
+    call_traits<impl, T, void(Property)>::overload == identity,
+    typename call_traits<impl, T, void(Property)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
       BOOST_ASIO_MOVE_ARG(Property)) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(Property)>::is_noexcept))
+      call_traits<impl, T, void(Property)>::is_noexcept))
   {
     return BOOST_ASIO_MOVE_CAST(T)(t);
   }
 
   template <typename T, typename Property>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(Property)>::overload == call_require_member,
-    typename call_traits<T, void(Property)>::result_type
+    call_traits<impl, T, void(Property)>::overload == call_require_member,
+    typename call_traits<impl, T, void(Property)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
       BOOST_ASIO_MOVE_ARG(Property) p) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(Property)>::is_noexcept))
+      call_traits<impl, T, void(Property)>::is_noexcept))
   {
     return BOOST_ASIO_MOVE_CAST(T)(t).require(
         BOOST_ASIO_MOVE_CAST(Property)(p));
@@ -402,14 +468,14 @@ struct impl
 
   template <typename T, typename Property>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(Property)>::overload == call_require_free,
-    typename call_traits<T, void(Property)>::result_type
+    call_traits<impl, T, void(Property)>::overload == call_require_free,
+    typename call_traits<impl, T, void(Property)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
       BOOST_ASIO_MOVE_ARG(Property) p) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(Property)>::is_noexcept))
+      call_traits<impl, T, void(Property)>::is_noexcept))
   {
     return require(
         BOOST_ASIO_MOVE_CAST(T)(t),
@@ -418,14 +484,14 @@ struct impl
 
   template <typename T, typename Property>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(Property)>::overload == call_prefer_member,
-    typename call_traits<T, void(Property)>::result_type
+    call_traits<impl, T, void(Property)>::overload == call_prefer_member,
+    typename call_traits<impl, T, void(Property)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
       BOOST_ASIO_MOVE_ARG(Property) p) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(Property)>::is_noexcept))
+      call_traits<impl, T, void(Property)>::is_noexcept))
   {
     return BOOST_ASIO_MOVE_CAST(T)(t).prefer(
         BOOST_ASIO_MOVE_CAST(Property)(p));
@@ -433,14 +499,14 @@ struct impl
 
   template <typename T, typename Property>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(Property)>::overload == call_prefer_free,
-    typename call_traits<T, void(Property)>::result_type
+    call_traits<impl, T, void(Property)>::overload == call_prefer_free,
+    typename call_traits<impl, T, void(Property)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
       BOOST_ASIO_MOVE_ARG(Property) p) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(Property)>::is_noexcept))
+      call_traits<impl, T, void(Property)>::is_noexcept))
   {
     return prefer(
         BOOST_ASIO_MOVE_CAST(T)(t),
@@ -449,15 +515,15 @@ struct impl
 
   template <typename T, typename P0, typename P1>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(P0, P1)>::overload == two_props,
-    typename call_traits<T, void(P0, P1)>::result_type
+    call_traits<impl, T, void(P0, P1)>::overload == two_props,
+    typename call_traits<impl, T, void(P0, P1)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
       BOOST_ASIO_MOVE_ARG(P0) p0,
       BOOST_ASIO_MOVE_ARG(P1) p1) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(P0, P1)>::is_noexcept))
+      call_traits<impl, T, void(P0, P1)>::is_noexcept))
   {
     return (*this)(
         (*this)(
@@ -469,8 +535,10 @@ struct impl
   template <typename T, typename P0, typename P1,
     typename BOOST_ASIO_ELLIPSIS PN>
   BOOST_ASIO_NODISCARD BOOST_ASIO_CONSTEXPR typename enable_if<
-    call_traits<T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::overload == n_props,
-    typename call_traits<T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::result_type
+    call_traits<impl, T,
+      void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::overload == n_props,
+    typename call_traits<impl, T,
+      void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::result_type
   >::type
   operator()(
       BOOST_ASIO_MOVE_ARG(T) t,
@@ -478,7 +546,7 @@ struct impl
       BOOST_ASIO_MOVE_ARG(P1) p1,
       BOOST_ASIO_MOVE_ARG(PN) BOOST_ASIO_ELLIPSIS pn) const
     BOOST_ASIO_NOEXCEPT_IF((
-      call_traits<T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::is_noexcept))
+      call_traits<impl, T, void(P0, P1, PN BOOST_ASIO_ELLIPSIS)>::is_noexcept))
   {
     return (*this)(
         (*this)(
@@ -508,13 +576,16 @@ static BOOST_ASIO_CONSTEXPR const asio_prefer_fn::impl&
 
 } // namespace
 
+typedef asio_prefer_fn::impl prefer_t;
+
 #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 template <typename T, typename... Properties>
 struct can_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(Properties...)>::overload
-      != asio_prefer_fn::ill_formed>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(Properties...)>::overload
+        != asio_prefer_fn::ill_formed>
 {
 };
 
@@ -524,24 +595,27 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct can_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(P0, P1, P2)>::overload
-      != asio_prefer_fn::ill_formed>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(P0, P1, P2)>::overload
+        != asio_prefer_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0, typename P1>
 struct can_prefer<T, P0, P1> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(P0, P1)>::overload
-      != asio_prefer_fn::ill_formed>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(P0, P1)>::overload
+        != asio_prefer_fn::ill_formed>
 {
 };
 
 template <typename T, typename P0>
 struct can_prefer<T, P0> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(P0)>::overload
-      != asio_prefer_fn::ill_formed>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(P0)>::overload
+        != asio_prefer_fn::ill_formed>
 {
 };
 
@@ -566,7 +640,8 @@ constexpr bool can_prefer_v
 template <typename T, typename... Properties>
 struct is_nothrow_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(Properties...)>::is_noexcept>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(Properties...)>::is_noexcept>
 {
 };
 
@@ -576,21 +651,24 @@ template <typename T, typename P0 = void,
     typename P1 = void, typename P2 = void>
 struct is_nothrow_prefer :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(P0, P1, P2)>::is_noexcept>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(P0, P1, P2)>::is_noexcept>
 {
 };
 
 template <typename T, typename P0, typename P1>
 struct is_nothrow_prefer<T, P0, P1> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(P0, P1)>::is_noexcept>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(P0, P1)>::is_noexcept>
 {
 };
 
 template <typename T, typename P0>
 struct is_nothrow_prefer<T, P0> :
   integral_constant<bool,
-    asio_prefer_fn::call_traits<T, void(P0)>::is_noexcept>
+    asio_prefer_fn::call_traits<
+      prefer_t, T, void(P0)>::is_noexcept>
 {
 };
 
@@ -616,7 +694,7 @@ template <typename T, typename... Properties>
 struct prefer_result
 {
   typedef typename asio_prefer_fn::call_traits<
-      T, void(Properties...)>::result_type type;
+      prefer_t, T, void(Properties...)>::result_type type;
 };
 
 #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
@@ -626,21 +704,21 @@ template <typename T, typename P0 = void,
 struct prefer_result
 {
   typedef typename asio_prefer_fn::call_traits<
-      T, void(P0, P1, P2)>::result_type type;
+      prefer_t, T, void(P0, P1, P2)>::result_type type;
 };
 
 template <typename T, typename P0, typename P1>
 struct prefer_result<T, P0, P1>
 {
   typedef typename asio_prefer_fn::call_traits<
-      T, void(P0, P1)>::result_type type;
+      prefer_t, T, void(P0, P1)>::result_type type;
 };
 
 template <typename T, typename P0>
 struct prefer_result<T, P0>
 {
   typedef typename asio_prefer_fn::call_traits<
-      T, void(P0)>::result_type type;
+      prefer_t, T, void(P0)>::result_type type;
 };
 
 template <typename T>