passenger 6.0.8 → 6.0.12

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

@@ -2,7 +2,7 @@
 // execution/bulk_guarantee.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)
@@ -199,8 +199,18 @@ struct bulk_guarantee_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);
@@ -231,17 +241,74 @@ struct bulk_guarantee_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, bulk_guarantee_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename static_proxy<T>::type, bulk_guarantee_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, bulk_guarantee_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, bulk_guarantee_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, bulk_guarantee_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename T>
@@ -249,9 +316,13 @@ struct bulk_guarantee_t
   typename traits::static_query<T, unsequenced_t>::result_type
   static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, bulk_guarantee_t>::is_valid
-          && !traits::query_member<T, bulk_guarantee_t>::is_valid
-          && traits::static_query<T, unsequenced_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, unsequenced_t>::is_valid
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return traits::static_query<T, unsequenced_t>::value();
@@ -262,10 +333,16 @@ struct bulk_guarantee_t
   typename traits::static_query<T, sequenced_t>::result_type
   static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, bulk_guarantee_t>::is_valid
-          && !traits::query_member<T, bulk_guarantee_t>::is_valid
-          && !traits::static_query<T, unsequenced_t>::is_valid
-          && traits::static_query<T, sequenced_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, unsequenced_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        traits::static_query<T, sequenced_t>::is_valid
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return traits::static_query<T, sequenced_t>::value();
@@ -276,11 +353,19 @@ struct bulk_guarantee_t
   typename traits::static_query<T, parallel_t>::result_type
   static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, bulk_guarantee_t>::is_valid
-          && !traits::query_member<T, bulk_guarantee_t>::is_valid
-          && !traits::static_query<T, unsequenced_t>::is_valid
-          && !traits::static_query<T, sequenced_t>::is_valid
-          && traits::static_query<T, parallel_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, unsequenced_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !traits::static_query<T, sequenced_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        traits::static_query<T, parallel_t>::is_valid
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return traits::static_query<T, parallel_t>::value();
@@ -335,7 +420,9 @@ struct bulk_guarantee_t
       const Executor& ex, convertible_from_bulk_guarantee_t,
       typename enable_if<
         !can_query<const Executor&, unsequenced_t>::value
-          && can_query<const Executor&, sequenced_t>::value
+      >::type* = 0,
+      typename enable_if<
+        can_query<const Executor&, sequenced_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.
@@ -356,8 +443,12 @@ struct bulk_guarantee_t
       const Executor& ex, convertible_from_bulk_guarantee_t,
       typename enable_if<
         !can_query<const Executor&, unsequenced_t>::value
-          && !can_query<const Executor&, sequenced_t>::value
-          && can_query<const Executor&, parallel_t>::value
+      >::type* = 0,
+      typename enable_if<
+        !can_query<const Executor&, sequenced_t>::value
+      >::type* = 0,
+      typename enable_if<
+        can_query<const Executor&, parallel_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.
@@ -416,8 +507,18 @@ struct unsequenced_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);
@@ -428,26 +529,46 @@ struct unsequenced_t
   {
   }
 
+  template <typename T>
+  struct query_member :
+    traits::query_member<
+      typename bulk_guarantee_t<I>::template proxy<T>::type,
+        unsequenced_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename bulk_guarantee_t<I>::template static_proxy<T>::type,
+        unsequenced_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, unsequenced_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, unsequenced_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, unsequenced_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename T>
   static BOOST_ASIO_CONSTEXPR unsequenced_t static_query(
       typename enable_if<
-        !traits::query_static_constexpr_member<T, unsequenced_t>::is_valid
-          && !traits::query_member<T, unsequenced_t>::is_valid
-          && !traits::query_free<T, unsequenced_t>::is_valid
-          && !can_query<T, sequenced_t<I> >::value
-          && !can_query<T, parallel_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, unsequenced_t>::is_valid
+      >::type* = 0,
+      typename enable_if<
+        !can_query<T, sequenced_t<I> >::value
+      >::type* = 0,
+      typename enable_if<
+        !can_query<T, parallel_t<I> >::value
       >::type* = 0) BOOST_ASIO_NOEXCEPT
   {
     return unsequenced_t();
@@ -514,8 +635,18 @@ struct sequenced_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);
@@ -526,16 +657,28 @@ struct sequenced_t
   {
   }
 
+  template <typename T>
+  struct query_member :
+    traits::query_member<
+      typename bulk_guarantee_t<I>::template proxy<T>::type,
+        sequenced_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename bulk_guarantee_t<I>::template static_proxy<T>::type,
+        sequenced_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, sequenced_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, sequenced_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, sequenced_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename E, typename T = decltype(sequenced_t::static_query<E>())>
@@ -599,8 +742,18 @@ struct parallel_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);
@@ -611,16 +764,28 @@ struct parallel_t
   {
   }
 
+  template <typename T>
+  struct query_member :
+    traits::query_member<
+      typename bulk_guarantee_t<I>::template proxy<T>::type,
+        parallel_t> {};
+
+  template <typename T>
+  struct query_static_constexpr_member :
+    traits::query_static_constexpr_member<
+      typename bulk_guarantee_t<I>::template static_proxy<T>::type,
+        parallel_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, parallel_t>::result_type
+  typename query_static_constexpr_member<T>::result_type
   static_query()
     BOOST_ASIO_NOEXCEPT_IF((
-      traits::query_static_constexpr_member<T, parallel_t>::is_noexcept))
+      query_static_constexpr_member<T>::is_noexcept))
   {
-    return traits::query_static_constexpr_member<T, parallel_t>::value();
+    return query_static_constexpr_member<T>::value();
   }
 
   template <typename E, typename T = decltype(parallel_t::static_query<E>())>
@@ -698,8 +863,16 @@ template <typename T>
 struct is_applicable_property<T, execution::bulk_guarantee_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>
 {
 };
 
@@ -707,8 +880,16 @@ template <typename T>
 struct is_applicable_property<T, execution::bulk_guarantee_t::unsequenced_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>
 {
 };
 
@@ -716,8 +897,16 @@ template <typename T>
 struct is_applicable_property<T, execution::bulk_guarantee_t::sequenced_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>
 {
 };
 
@@ -725,8 +914,16 @@ template <typename T>
 struct is_applicable_property<T, execution::bulk_guarantee_t::parallel_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>
 {
 };
 
@@ -786,30 +983,30 @@ struct query_free_default<T, execution::bulk_guarantee_t,
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::bulk_guarantee_t>::is_valid
+    execution::detail::bulk_guarantee_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::bulk_guarantee_t>::result_type result_type;
+  typedef typename execution::detail::bulk_guarantee_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::bulk_guarantee_t>::value();
+    return execution::detail::bulk_guarantee_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };
 
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T,
-        execution::bulk_guarantee_t>::is_valid
-      && !traits::query_member<T,
-        execution::bulk_guarantee_t>::is_valid
+    !execution::detail::bulk_guarantee_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::bulk_guarantee_t<0>::
+        query_member<T>::is_valid
       && traits::static_query<T,
         execution::bulk_guarantee_t::unsequenced_t>::is_valid
   >::type>
@@ -830,10 +1027,10 @@ struct static_query<T, execution::bulk_guarantee_t,
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T,
-        execution::bulk_guarantee_t>::is_valid
-      && !traits::query_member<T,
-        execution::bulk_guarantee_t>::is_valid
+    !execution::detail::bulk_guarantee_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::bulk_guarantee_t<0>::
+        query_member<T>::is_valid
       && !traits::static_query<T,
         execution::bulk_guarantee_t::unsequenced_t>::is_valid
       && traits::static_query<T,
@@ -856,10 +1053,10 @@ struct static_query<T, execution::bulk_guarantee_t,
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T,
-        execution::bulk_guarantee_t>::is_valid
-      && !traits::query_member<T,
-        execution::bulk_guarantee_t>::is_valid
+    !execution::detail::bulk_guarantee_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::bulk_guarantee_t<0>::
+        query_member<T>::is_valid
       && !traits::static_query<T,
         execution::bulk_guarantee_t::unsequenced_t>::is_valid
       && !traits::static_query<T,
@@ -884,30 +1081,30 @@ struct static_query<T, execution::bulk_guarantee_t,
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t::unsequenced_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::bulk_guarantee_t::unsequenced_t>::is_valid
+    execution::detail::bulk_guarantee::unsequenced_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::bulk_guarantee_t::unsequenced_t>::result_type result_type;
+  typedef typename execution::detail::bulk_guarantee::unsequenced_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::bulk_guarantee_t::unsequenced_t>::value();
+    return execution::detail::bulk_guarantee::unsequenced_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };
 
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t::unsequenced_t,
   typename enable_if<
-    !traits::query_static_constexpr_member<T,
-      execution::bulk_guarantee_t::unsequenced_t>::is_valid
-      && !traits::query_member<T,
-        execution::bulk_guarantee_t::unsequenced_t>::is_valid
+    !execution::detail::bulk_guarantee::unsequenced_t<0>::
+        query_static_constexpr_member<T>::is_valid
+      && !execution::detail::bulk_guarantee::unsequenced_t<0>::
+        query_member<T>::is_valid
       && !traits::query_free<T,
         execution::bulk_guarantee_t::unsequenced_t>::is_valid
       && !can_query<T, execution::bulk_guarantee_t::sequenced_t>::value
@@ -928,40 +1125,40 @@ struct static_query<T, execution::bulk_guarantee_t::unsequenced_t,
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t::sequenced_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::bulk_guarantee_t::sequenced_t>::is_valid
+    execution::detail::bulk_guarantee::sequenced_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::bulk_guarantee_t::sequenced_t>::result_type result_type;
+  typedef typename execution::detail::bulk_guarantee::sequenced_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::bulk_guarantee_t::sequenced_t>::value();
+    return execution::detail::bulk_guarantee::sequenced_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };
 
 template <typename T>
 struct static_query<T, execution::bulk_guarantee_t::parallel_t,
   typename enable_if<
-    traits::query_static_constexpr_member<T,
-      execution::bulk_guarantee_t::parallel_t>::is_valid
+    execution::detail::bulk_guarantee::parallel_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::bulk_guarantee_t::parallel_t>::result_type result_type;
+  typedef typename execution::detail::bulk_guarantee::parallel_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::bulk_guarantee_t::parallel_t>::value();
+    return execution::detail::bulk_guarantee::parallel_t<0>::
+      query_static_constexpr_member<T>::value();
   }
 };