passenger 6.0.8 → 6.0.9

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/any_executor.hpp

@@ -2,7 +2,7 @@
 // execution/any_executor.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)
@@ -620,7 +620,11 @@ public:
     return static_cast<Executor*>(target_);
   }
 
+#if !defined(BOOST_ASIO_NO_TYPEID)
   const std::type_info& target_type() const
+#else // !defined(BOOST_ASIO_NO_TYPEID)
+  const void* target_type() const
+#endif // !defined(BOOST_ASIO_NO_TYPEID)
   {
     return target_fns_->target_type();
   }
@@ -800,16 +804,27 @@ protected:
 
   struct target_fns
   {
+#if !defined(BOOST_ASIO_NO_TYPEID)
     const std::type_info& (*target_type)();
+#else // !defined(BOOST_ASIO_NO_TYPEID)
+    const void* (*target_type)();
+#endif // !defined(BOOST_ASIO_NO_TYPEID)
     bool (*equal)(const any_executor_base&, const any_executor_base&);
     void (*execute)(const any_executor_base&, BOOST_ASIO_MOVE_ARG(function));
     void (*blocking_execute)(const any_executor_base&, function_view);
   };
 
+#if !defined(BOOST_ASIO_NO_TYPEID)
   static const std::type_info& target_type_void()
   {
     return typeid(void);
   }
+#else // !defined(BOOST_ASIO_NO_TYPEID)
+  static const void* target_type_void()
+  {
+    return 0;
+  }
+#endif // !defined(BOOST_ASIO_NO_TYPEID)
 
   static bool equal_void(const any_executor_base&, const any_executor_base&)
   {
@@ -845,11 +860,20 @@ protected:
     return &fns;
   }
 
+#if !defined(BOOST_ASIO_NO_TYPEID)
   template <typename Ex>
   static const std::type_info& target_type_ex()
   {
     return typeid(Ex);
   }
+#else // !defined(BOOST_ASIO_NO_TYPEID)
+  template <typename Ex>
+  static const void* target_type_ex()
+  {
+    static int unique_id;
+    return &unique_id;
+  }
+#endif // !defined(BOOST_ASIO_NO_TYPEID)
 
   template <typename Ex>
   static bool equal_ex(const any_executor_base& ex1,
@@ -1280,39 +1304,65 @@ public:
   {
     return any_executor_base::equality_helper(other);
   }
-};
 
-inline bool operator==(const any_executor<>& a,
-    const any_executor<>& b) BOOST_ASIO_NOEXCEPT
-{
-  return a.equality_helper(b);
-}
+  template <typename AnyExecutor1, typename AnyExecutor2>
+  friend typename enable_if<
+    is_same<AnyExecutor1, any_executor>::value
+      || is_same<AnyExecutor2, any_executor>::value,
+    bool
+  >::type operator==(const AnyExecutor1& a,
+      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  {
+    return static_cast<const any_executor&>(a).equality_helper(b);
+  }
 
-inline bool operator==(const any_executor<>& a, nullptr_t) BOOST_ASIO_NOEXCEPT
-{
-  return !a;
-}
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator==(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    return !a;
+  }
 
-inline bool operator==(nullptr_t, const any_executor<>& b) BOOST_ASIO_NOEXCEPT
-{
-  return !b;
-}
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator==(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  {
+    return !b;
+  }
 
-inline bool operator!=(const any_executor<>& a,
-    const any_executor<>& b) BOOST_ASIO_NOEXCEPT
-{
-  return !a.equality_helper(b);
-}
+  template <typename AnyExecutor1, typename AnyExecutor2>
+  friend typename enable_if<
+    is_same<AnyExecutor1, any_executor>::value
+      || is_same<AnyExecutor2, any_executor>::value,
+    bool
+  >::type operator!=(const AnyExecutor1& a,
+      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  {
+    return !static_cast<const any_executor&>(a).equality_helper(b);
+  }
 
-inline bool operator!=(const any_executor<>& a, nullptr_t) BOOST_ASIO_NOEXCEPT
-{
-  return !!a;
-}
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator!=(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    return !!a;
+  }
 
-inline bool operator!=(nullptr_t, const any_executor<>& b) BOOST_ASIO_NOEXCEPT
-{
-  return !!b;
-}
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator!=(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  {
+    return !!b;
+  }
+};
 
 inline void swap(any_executor<>& a, any_executor<>& b) BOOST_ASIO_NOEXCEPT
 {
@@ -1452,6 +1502,64 @@ public:
     return any_executor_base::equality_helper(other);
   }
 
+  template <typename AnyExecutor1, typename AnyExecutor2>
+  friend typename enable_if<
+    is_same<AnyExecutor1, any_executor>::value
+      || is_same<AnyExecutor2, any_executor>::value,
+    bool
+  >::type operator==(const AnyExecutor1& a,
+      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  {
+    return static_cast<const any_executor&>(a).equality_helper(b);
+  }
+
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator==(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    return !a;
+  }
+
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator==(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  {
+    return !b;
+  }
+
+  template <typename AnyExecutor1, typename AnyExecutor2>
+  friend typename enable_if<
+    is_same<AnyExecutor1, any_executor>::value
+      || is_same<AnyExecutor2, any_executor>::value,
+    bool
+  >::type operator!=(const AnyExecutor1& a,
+      const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT
+  {
+    return !static_cast<const any_executor&>(a).equality_helper(b);
+  }
+
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator!=(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT
+  {
+    return !!a;
+  }
+
+  template <typename AnyExecutor>
+  friend typename enable_if<
+    is_same<AnyExecutor, any_executor>::value,
+    bool
+  >::type operator!=(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT
+  {
+    return !!b;
+  }
+
   template <typename T>
   struct find_convertible_property :
       detail::supportable_properties<
@@ -1596,48 +1704,6 @@ public:
   const prop_fns<any_executor>* prop_fns_;
 };
 
-template <typename... SupportableProperties>
-inline bool operator==(const any_executor<SupportableProperties...>& a,
-    const any_executor<SupportableProperties...>& b) BOOST_ASIO_NOEXCEPT
-{
-  return a.equality_helper(b);
-}
-
-template <typename... SupportableProperties>
-inline bool operator==(const any_executor<SupportableProperties...>& a,
-    nullptr_t) BOOST_ASIO_NOEXCEPT
-{
-  return !a;
-}
-
-template <typename... SupportableProperties>
-inline bool operator==(nullptr_t,
-    const any_executor<SupportableProperties...>& b) BOOST_ASIO_NOEXCEPT
-{
-  return !b;
-}
-
-template <typename... SupportableProperties>
-inline bool operator!=(const any_executor<SupportableProperties...>& a,
-    const any_executor<SupportableProperties...>& b) BOOST_ASIO_NOEXCEPT
-{
-  return !a.equality_helper(b);
-}
-
-template <typename... SupportableProperties>
-inline bool operator!=(const any_executor<SupportableProperties...>& a,
-    nullptr_t) BOOST_ASIO_NOEXCEPT
-{
-  return !!a;
-}
-
-template <typename... SupportableProperties>
-inline bool operator!=(nullptr_t,
-    const any_executor<SupportableProperties...>& b) BOOST_ASIO_NOEXCEPT
-{
-  return !!b;
-}
-
 template <typename... SupportableProperties>
 inline void swap(any_executor<SupportableProperties...>& a,
     any_executor<SupportableProperties...>& b) BOOST_ASIO_NOEXCEPT
@@ -1851,6 +1917,64 @@ inline void swap(any_executor<SupportableProperties...>& a,
       return any_executor_base::equality_helper(other); \
     } \
     \
+    template <typename AnyExecutor1, typename AnyExecutor2> \
+    friend typename enable_if< \
+      is_same<AnyExecutor1, any_executor>::value \
+        || is_same<AnyExecutor2, any_executor>::value, \
+      bool \
+    >::type operator==(const AnyExecutor1& a, \
+        const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT \
+    { \
+      return static_cast<const any_executor&>(a).equality_helper(b); \
+    } \
+    \
+    template <typename AnyExecutor> \
+    friend typename enable_if< \
+      is_same<AnyExecutor, any_executor>::value, \
+      bool \
+    >::type operator==(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT \
+    { \
+      return !a; \
+    } \
+    \
+    template <typename AnyExecutor> \
+    friend typename enable_if< \
+      is_same<AnyExecutor, any_executor>::value, \
+      bool \
+    >::type operator==(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT \
+    { \
+      return !b; \
+    } \
+    \
+    template <typename AnyExecutor1, typename AnyExecutor2> \
+    friend typename enable_if< \
+      is_same<AnyExecutor1, any_executor>::value \
+        || is_same<AnyExecutor2, any_executor>::value, \
+      bool \
+    >::type operator!=(const AnyExecutor1& a, \
+        const AnyExecutor2& b) BOOST_ASIO_NOEXCEPT \
+    { \
+      return !static_cast<const any_executor&>(a).equality_helper(b); \
+    } \
+    \
+    template <typename AnyExecutor> \
+    friend typename enable_if< \
+      is_same<AnyExecutor, any_executor>::value, \
+      bool \
+    >::type operator!=(const AnyExecutor& a, nullptr_t) BOOST_ASIO_NOEXCEPT \
+    { \
+      return !!a; \
+    } \
+    \
+    template <typename AnyExecutor> \
+    friend typename enable_if< \
+      is_same<AnyExecutor, any_executor>::value, \
+      bool \
+    >::type operator!=(nullptr_t, const AnyExecutor& b) BOOST_ASIO_NOEXCEPT \
+    { \
+      return !!b; \
+    } \
+    \
     template <typename T> \
     struct find_convertible_property : \
         detail::supportable_properties< \
@@ -1990,48 +2114,6 @@ inline void swap(any_executor<SupportableProperties...>& a,
   }; \
   \
   template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline bool operator==(const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& a, \
-      const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& b) BOOST_ASIO_NOEXCEPT \
-  { \
-    return a.equality_helper(b); \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline bool operator==(const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& a, \
-      nullptr_t) BOOST_ASIO_NOEXCEPT \
-  { \
-    return !a; \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline bool operator==(nullptr_t, \
-      const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& b) BOOST_ASIO_NOEXCEPT \
-  { \
-    return !b; \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline bool operator!=(const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& a, \
-      const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& b) BOOST_ASIO_NOEXCEPT \
-  { \
-    return !a.equality_helper(b); \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline bool operator!=(const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& a, \
-      nullptr_t) BOOST_ASIO_NOEXCEPT \
-  { \
-    return !!a; \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
-  inline bool operator!=(nullptr_t, \
-      const any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& b) BOOST_ASIO_NOEXCEPT \
-  { \
-    return !!b; \
-  } \
-  \
-  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
   inline void swap(any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& a, \
       any_executor<BOOST_ASIO_VARIADIC_TARGS(n)>& b) BOOST_ASIO_NOEXCEPT \
   { \

data/src/cxx_supportlib/vendor-modified/boost/asio/execution/bad_executor.hpp

@@ -2,7 +2,7 @@
 // execution/bad_executor.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/execution/blocking.hpp

@@ -2,7 +2,7 @@
 // execution/blocking.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)
@@ -211,8 +211,18 @@ struct blocking_t
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
   template <typename T>
   BOOST_ASIO_STATIC_CONSTEXPR(bool,
-    is_applicable_property_v = is_executor<T>::value
-      || is_sender<T>::value || is_scheduler<T>::value);
+    is_applicable_property_v = (
+      is_executor<T>::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_sender<T>
+          >::type::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_scheduler<T>
+          >::type::value));
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = false);
@@ -243,16 +253,74 @@ struct blocking_t
   {
   }
 
+  template <typename T>
+  struct proxy
+  {
+#if defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+    struct type
+    {
+      template <typename P>
+      auto query(BOOST_ASIO_MOVE_ARG(P) p) const
+        noexcept(
+          noexcept(
+            declval<typename conditional<true, T, P>::type>().query(
+              BOOST_ASIO_MOVE_CAST(P)(p))
+          )
+        )
+        -> decltype(
+          declval<typename conditional<true, T, P>::type>().query(
+            BOOST_ASIO_MOVE_CAST(P)(p))
+        );
+    };
+#else // defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+    typedef T type;
+#endif // defined(BOOST_ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
+  };
+
+  template <typename T>
+  struct static_proxy
+  {
+#if defined(BOOST_ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+    struct type
+    {
+      template <typename P>
+      static constexpr auto query(BOOST_ASIO_MOVE_ARG(P) p)
+        noexcept(
+          noexcept(
+            conditional<true, T, P>::type::query(BOOST_ASIO_MOVE_CAST(P)(p))
+          )
+        )
+        -> decltype(
+          conditional<true, T, P>::type::query(BOOST_ASIO_MOVE_CAST(P)(p))
+        )
+      {
+        return T::query(BOOST_ASIO_MOVE_CAST(P)(p));
+      }
+    };
+#else // defined(BOOST_ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+    typedef T type;
+#endif // defined(BOOST_ASIO_HAS_DEDUCED_QUERY_STATIC_CONSTEXPR_MEMBER_TRAIT)
+  };
+
+  template <typename T>
+  struct query_member :
+    traits::query_member<typename proxy<T>::type, blocking_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename static_proxy<T>::type, blocking_t> {};
+
 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
   template <typename T>
   static BOOST_ASIO_CONSTEXPR
-  typename traits::query_static_constexpr_member<T, blocking_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, blocking_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, blocking_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename T>
@@ -260,9 +328,13 @@ struct blocking_t
   typename traits::static_query<T, possibly_t>::result_type
   static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, blocking_t>::is_valid
-          && !traits::query_member<T, blocking_t>::is_valid
-          && traits::static_query<T, possibly_t>::is_valid
+        !query_static_constexpr_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !query_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        traits::static_query<T, possibly_t>::is_valid
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return traits::static_query<T, possibly_t>::value();
@@ -273,10 +345,16 @@ struct blocking_t
   typename traits::static_query<T, always_t>::result_type
   static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, blocking_t>::is_valid
-          && !traits::query_member<T, blocking_t>::is_valid
-          && !traits::static_query<T, possibly_t>::is_valid
-          && traits::static_query<T, always_t>::is_valid
+        !query_static_constexpr_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !query_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !traits::static_query<T, possibly_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        traits::static_query<T, always_t>::is_valid
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return traits::static_query<T, always_t>::value();
@@ -287,11 +365,19 @@ struct blocking_t
   typename traits::static_query<T, never_t>::result_type
   static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, blocking_t>::is_valid
-          && !traits::query_member<T, blocking_t>::is_valid
-          && !traits::static_query<T, possibly_t>::is_valid
-          && !traits::static_query<T, always_t>::is_valid
-          && traits::static_query<T, never_t>::is_valid
+        !query_static_constexpr_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !query_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !traits::static_query<T, possibly_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !traits::static_query<T, always_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        traits::static_query<T, never_t>::is_valid
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return traits::static_query<T, never_t>::value();
@@ -344,7 +430,9 @@ struct blocking_t
       const Executor& ex, convertible_from_blocking_t,
       typename enable_if<
         !can_query<const Executor&, possibly_t>::value
-          && can_query<const Executor&, always_t>::value
+      >::type* = 0,
+      typename enable_if<
+        can_query<const Executor&, always_t>::value
       >::type* = 0)
 #if !defined(__clang__) // Clang crashes if noexcept is used here.
 #if defined(BOOST_ASIO_MSVC) // Visual C++ wants the type to be qualified.
@@ -364,8 +452,12 @@ struct blocking_t
       const Executor& ex, convertible_from_blocking_t,
       typename enable_if<
         !can_query<const Executor&, possibly_t>::value
-          && !can_query<const Executor&, always_t>::value
-          && can_query<const Executor&, never_t>::value
+      >::type* = 0,
+      typename enable_if<
+        !can_query<const Executor&, always_t>::value
+      >::type* = 0,
+      typename enable_if<
+        can_query<const Executor&, never_t>::value
       >::type* = 0)
 #if !defined(__clang__) // Clang crashes if noexcept is used here.
 #if defined(BOOST_ASIO_MSVC) // Visual C++ wants the type to be qualified.
@@ -421,8 +513,18 @@ struct possibly_t
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
   template <typename T>
   BOOST_ASIO_STATIC_CONSTEXPR(bool,
-    is_applicable_property_v = is_executor<T>::value
-      || is_sender<T>::value || is_scheduler<T>::value);
+    is_applicable_property_v = (
+      is_executor<T>::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_sender<T>
+          >::type::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_scheduler<T>
+          >::type::value));
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
@@ -433,26 +535,44 @@ struct possibly_t
   {
   }
 
+  template <typename T>
+  struct query_member :
+    traits::query_member<
+      typename blocking_t<I>::template proxy<T>::type, possibly_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename blocking_t<I>::template static_proxy<T>::type, possibly_t> {};
+
 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
   template <typename T>
   static BOOST_ASIO_CONSTEXPR
-  typename traits::query_static_constexpr_member<T, possibly_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, possibly_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, possibly_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename T>
   static BOOST_ASIO_CONSTEXPR possibly_t static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, possibly_t>::is_valid
-          && !traits::query_member<T, possibly_t>::is_valid
-          && !traits::query_free<T, possibly_t>::is_valid
-          && !can_query<T, always_t<I> >::value
-          && !can_query<T, never_t<I> >::value
+        !query_static_constexpr_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !query_member<T>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !traits::query_free<T, possibly_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !can_query<T, always_t<I> >::value
+      >::type* = 0,
+      typename enable_if<
+        !can_query<T, never_t<I> >::value
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return possibly_t();
@@ -650,8 +770,18 @@ struct always_t
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
   template <typename T>
   BOOST_ASIO_STATIC_CONSTEXPR(bool,
-    is_applicable_property_v = is_executor<T>::value
-      || is_sender<T>::value || is_scheduler<T>::value);
+    is_applicable_property_v = (
+      is_executor<T>::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_sender<T>
+          >::type::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_scheduler<T>
+          >::type::value));
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
@@ -662,16 +792,26 @@ struct always_t
   {
   }
 
+  template <typename T>
+  struct query_member :
+    traits::query_member<
+      typename blocking_t<I>::template proxy<T>::type, always_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename blocking_t<I>::template static_proxy<T>::type, always_t> {};
+
 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
   template <typename T>
   static BOOST_ASIO_CONSTEXPR
-  typename traits::query_static_constexpr_member<T, always_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, always_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, always_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename E, typename T = decltype(always_t::static_query<E>())>
@@ -726,7 +866,9 @@ struct always_t
       const Executor& e, const always_t&,
       typename enable_if<
         is_executor<Executor>::value
-        && traits::static_require<
+      >::type* = 0,
+      typename enable_if<
+        traits::static_require<
           const Executor&,
           blocking_adaptation::allowed_t<0>
         >::is_valid
@@ -749,8 +891,18 @@ struct never_t
 #if defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
   template <typename T>
   BOOST_ASIO_STATIC_CONSTEXPR(bool,
-    is_applicable_property_v = is_executor<T>::value
-      || is_sender<T>::value || is_scheduler<T>::value);
+    is_applicable_property_v = (
+      is_executor<T>::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_sender<T>
+          >::type::value
+        || conditional<
+            is_executor<T>::value,
+            false_type,
+            is_scheduler<T>
+          >::type::value));
 #endif // defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES)
 
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_requirable = true);
@@ -761,16 +913,26 @@ struct never_t
   {
   }
 
+  template <typename T>
+  struct query_member :
+    traits::query_member<
+      typename blocking_t<I>::template proxy<T>::type, never_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename blocking_t<I>::template static_proxy<T>::type, never_t> {};
+
 #if defined(BOOST_ASIO_HAS_DEDUCED_STATIC_QUERY_TRAIT) \
   && defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES)
   template <typename T>
   static BOOST_ASIO_CONSTEXPR
-  typename traits::query_static_constexpr_member<T, never_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, never_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, never_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename E, typename T = decltype(never_t::static_query<E>())>
@@ -846,8 +1008,16 @@ template <typename T>
 struct is_applicable_property<T, execution::blocking_t>
   : integral_constant<bool,
       execution::is_executor<T>::value
-        || execution::is_sender<T>::value
-        || execution::is_scheduler<T>::value>
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_sender<T>
+          >::type::value
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_scheduler<T>
+          >::type::value>
 {
 };
 
@@ -855,8 +1025,16 @@ template <typename T>
 struct is_applicable_property<T, execution::blocking_t::possibly_t>
   : integral_constant<bool,
       execution::is_executor<T>::value
-        || execution::is_sender<T>::value
-        || execution::is_scheduler<T>::value>
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_sender<T>
+          >::type::value
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_scheduler<T>
+          >::type::value>
 {
 };
 
@@ -864,8 +1042,16 @@ template <typename T>
 struct is_applicable_property<T, execution::blocking_t::always_t>
   : integral_constant<bool,
       execution::is_executor<T>::value
-        || execution::is_sender<T>::value
-        || execution::is_scheduler<T>::value>
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_sender<T>
+          >::type::value
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_scheduler<T>
+          >::type::value>
 {
 };
 
@@ -873,8 +1059,16 @@ template <typename T>
 struct is_applicable_property<T, execution::blocking_t::never_t>
   : integral_constant<bool,
       execution::is_executor<T>::value
-        || execution::is_sender<T>::value
-        || execution::is_scheduler<T>::value>
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_sender<T>
+          >::type::value
+        || conditional<
+            execution::is_executor<T>::value,
+            false_type,
+            execution::is_scheduler<T>
+          >::type::value>
 {
 };
 
@@ -934,28 +1128,29 @@ struct query_free_default<T, execution::blocking_t,
 template <typename T>
 struct static_query<T, execution::blocking_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::blocking_t>::is_valid
+    execution::detail::blocking_t<0>::
+      query_static_constexpr_member<T>::is_valid
   >::type>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 
-  typedef typename traits::query_static_constexpr_member<T,
-    execution::blocking_t>::result_type result_type;
+  typedef typename execution::detail::blocking_t<0>::
+    query_static_constexpr_member<T>::result_type result_type;
 
   static BOOST_ASIO_CONSTEXPR result_type value()
   {
-    return traits::query_static_constexpr_member<T,
-      execution::blocking_t>::value();
+    return execution::blocking_t::query_static_constexpr_member<T>::value();
   }
 };
 
 template <typename T>
 struct static_query<T, execution::blocking_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T, execution::blocking_t>::is_valid
-      && !traits::query_member<T, execution::blocking_t>::is_valid
+    !execution::detail::blocking_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::blocking_t<0>::
+        query_member<T>::is_valid
       && traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
   >::type>
 {
@@ -974,8 +1169,10 @@ struct static_query<T, execution::blocking_t,
 template <typename T>
 struct static_query<T, execution::blocking_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T, execution::blocking_t>::is_valid
-      && !traits::query_member<T, execution::blocking_t>::is_valid
+    !execution::detail::blocking_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::blocking_t<0>::
+        query_member<T>::is_valid
       && !traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
       && traits::static_query<T, execution::blocking_t::always_t>::is_valid
   >::type>
@@ -995,8 +1192,10 @@ struct static_query<T, execution::blocking_t,
 template <typename T>
 struct static_query<T, execution::blocking_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T, execution::blocking_t>::is_valid
-      && !traits::query_member<T, execution::blocking_t>::is_valid
+    !execution::detail::blocking_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::blocking_t<0>::
+        query_member<T>::is_valid
       && !traits::static_query<T, execution::blocking_t::possibly_t>::is_valid
       && !traits::static_query<T, execution::blocking_t::always_t>::is_valid
       && traits::static_query<T, execution::blocking_t::never_t>::is_valid
@@ -1017,29 +1216,30 @@ struct static_query<T, execution::blocking_t,
 template <typename T>
 struct static_query<T, execution::blocking_t::possibly_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::blocking_t::possibly_t>::is_valid
+    execution::detail::blocking::possibly_t<0>::
+      query_static_constexpr_member<T>::is_valid
   >::type>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 
-  typedef typename traits::query_static_constexpr_member<T,
-    execution::blocking_t::possibly_t>::result_type result_type;
+  typedef typename execution::detail::blocking::possibly_t<0>::
+    query_static_constexpr_member<T>::result_type result_type;
 
   static BOOST_ASIO_CONSTEXPR result_type value()
   {
-    return traits::query_static_constexpr_member<T,
-      execution::blocking_t::possibly_t>::value();
+    return execution::detail::blocking::possibly_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };
 
 template <typename T>
 struct static_query<T, execution::blocking_t::possibly_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T,
-      execution::blocking_t::possibly_t>::is_valid
-      && !traits::query_member<T, execution::blocking_t::possibly_t>::is_valid
+    !execution::detail::blocking::possibly_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::blocking::possibly_t<0>::
+        query_member<T>::is_valid
       && !traits::query_free<T, execution::blocking_t::possibly_t>::is_valid
       && !can_query<T, execution::blocking_t::always_t>::value
       && !can_query<T, execution::blocking_t::never_t>::value
@@ -1059,40 +1259,40 @@ struct static_query<T, execution::blocking_t::possibly_t,
 template <typename T>
 struct static_query<T, execution::blocking_t::always_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::blocking_t::always_t>::is_valid
+    execution::detail::blocking::always_t<0>::
+      query_static_constexpr_member<T>::is_valid
   >::type>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 
-  typedef typename traits::query_static_constexpr_member<T,
-    execution::blocking_t::always_t>::result_type result_type;
+  typedef typename execution::detail::blocking::always_t<0>::
+    query_static_constexpr_member<T>::result_type result_type;
 
   static BOOST_ASIO_CONSTEXPR result_type value()
   {
-    return traits::query_static_constexpr_member<T,
-      execution::blocking_t::always_t>::value();
+    return execution::detail::blocking::always_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };
 
 template <typename T>
 struct static_query<T, execution::blocking_t::never_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::blocking_t::never_t>::is_valid
+    execution::detail::blocking::never_t<0>::
+      query_static_constexpr_member<T>::is_valid
   >::type>
 {
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_valid = true);
   BOOST_ASIO_STATIC_CONSTEXPR(bool, is_noexcept = true);
 
-  typedef typename traits::query_static_constexpr_member<T,
-    execution::blocking_t::never_t>::result_type result_type;
+  typedef typename execution::detail::blocking::never_t<0>::
+    query_static_constexpr_member<T>::result_type result_type;
 
   static BOOST_ASIO_CONSTEXPR result_type value()
   {
-    return traits::query_static_constexpr_member<T,
-      execution::blocking_t::never_t>::value();
+    return execution::detail::blocking::never_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };