couchbase 3.0.0 → 3.0.1

data/ext/third_party/asio/asio/include/asio/impl/buffered_write_stream.hpp

@@ -86,19 +86,29 @@ namespace detail
   };
 
   template <typename WriteHandler>
-  inline void* asio_handler_allocate(std::size_t size,
+  inline asio_handler_allocate_is_deprecated
+  asio_handler_allocate(std::size_t size,
       buffered_flush_handler<WriteHandler>* this_handler)
   {
+#if defined(ASIO_NO_DEPRECATED)
+    asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+    return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename WriteHandler>
-  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+  inline asio_handler_deallocate_is_deprecated
+  asio_handler_deallocate(void* pointer, std::size_t size,
       buffered_flush_handler<WriteHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename WriteHandler>
@@ -110,19 +120,27 @@ namespace detail
   }
 
   template <typename Function, typename WriteHandler>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       buffered_flush_handler<WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Function, typename WriteHandler>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       buffered_flush_handler<WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Stream>
@@ -298,21 +316,31 @@ namespace detail
   };
 
   template <typename ConstBufferSequence, typename WriteHandler>
-  inline void* asio_handler_allocate(std::size_t size,
+  inline asio_handler_allocate_is_deprecated
+  asio_handler_allocate(std::size_t size,
       buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>* this_handler)
   {
+#if defined(ASIO_NO_DEPRECATED)
+    asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+    return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename ConstBufferSequence, typename WriteHandler>
-  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+  inline asio_handler_deallocate_is_deprecated
+  asio_handler_deallocate(void* pointer, std::size_t size,
       buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename ConstBufferSequence, typename WriteHandler>
@@ -326,22 +354,30 @@ namespace detail
 
   template <typename Function, typename ConstBufferSequence,
       typename WriteHandler>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Function, typename ConstBufferSequence,
       typename WriteHandler>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       buffered_write_some_handler<
         ConstBufferSequence, WriteHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Stream>

data/ext/third_party/asio/asio/include/asio/impl/co_spawn.hpp

@@ -18,7 +18,9 @@
 #include "asio/detail/config.hpp"
 #include "asio/awaitable.hpp"
 #include "asio/dispatch.hpp"
+#include "asio/execution/outstanding_work.hpp"
 #include "asio/post.hpp"
+#include "asio/prefer.hpp"
 #include "asio/use_awaitable.hpp"
 
 #include "asio/detail/push_options.hpp"
@@ -26,12 +28,60 @@
 namespace asio {
 namespace detail {
 
+template <typename Executor, typename = void>
+class co_spawn_work_guard
+{
+public:
+  typedef typename decay<
+      typename prefer_result<Executor,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type executor_type;
+
+  co_spawn_work_guard(const Executor& ex)
+    : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
+  {
+  }
+
+  executor_type get_executor() const ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+private:
+  executor_type executor_;
+};
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+struct co_spawn_work_guard<Executor,
+    typename enable_if<
+      !execution::is_executor<Executor>::value
+    >::type> : executor_work_guard<Executor>
+{
+  co_spawn_work_guard(const Executor& ex)
+    : executor_work_guard<Executor>(ex)
+  {
+  }
+};
+
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+inline co_spawn_work_guard<Executor>
+make_co_spawn_work_guard(const Executor& ex)
+{
+  return co_spawn_work_guard<Executor>(ex);
+}
+
 template <typename T, typename Executor, typename F, typename Handler>
 awaitable<void, Executor> co_spawn_entry_point(
     awaitable<T, Executor>*, Executor ex, F f, Handler handler)
 {
-  auto spawn_work = make_work_guard(ex);
-  auto handler_work = make_work_guard(handler, ex);
+  auto spawn_work = make_co_spawn_work_guard(ex);
+  auto handler_work = make_co_spawn_work_guard(
+      asio::get_associated_executor(handler, ex));
 
   (void) co_await (post)(spawn_work.get_executor(),
       use_awaitable_t<Executor>{});
@@ -66,11 +116,12 @@ template <typename Executor, typename F, typename Handler>
 awaitable<void, Executor> co_spawn_entry_point(
     awaitable<void, Executor>*, Executor ex, F f, Handler handler)
 {
-  auto spawn_work = make_work_guard(ex);
-  auto handler_work = make_work_guard(handler, ex);
+  auto spawn_work = make_co_spawn_work_guard(ex);
+  auto handler_work = make_co_spawn_work_guard(
+      asio::get_associated_executor(handler, ex));
 
   (void) co_await (post)(spawn_work.get_executor(),
-      use_awaitable_t<Executor>{});
+      use_awaitable_t<Executor>{__FILE__, __LINE__, "co_spawn_entry_point"});
 
   std::exception_ptr e = nullptr;
   try
@@ -89,6 +140,24 @@ awaitable<void, Executor> co_spawn_entry_point(
       });
 }
 
+template <typename T, typename Executor>
+class awaitable_as_function
+{
+public:
+  explicit awaitable_as_function(awaitable<T, Executor>&& a)
+    : awaitable_(std::move(a))
+  {
+  }
+
+  awaitable<T, Executor> operator()()
+  {
+    return std::move(awaitable_);
+  }
+
+private:
+  awaitable<T, Executor> awaitable_;
+};
+
 template <typename Executor>
 class initiate_co_spawn
 {
@@ -122,6 +191,75 @@ private:
 
 } // namespace detail
 
+template <typename Executor, typename T, typename AwaitableExecutor,
+    ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr, T)) CompletionToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr, T))
+co_spawn(const Executor& ex,
+    awaitable<T, AwaitableExecutor> a, CompletionToken&& token,
+    typename enable_if<
+      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
+        && is_convertible<Executor, AwaitableExecutor>::value
+    >::type*)
+{
+  return async_initiate<CompletionToken, void(std::exception_ptr, T)>(
+      detail::initiate_co_spawn<AwaitableExecutor>(AwaitableExecutor(ex)),
+      token, detail::awaitable_as_function<T, AwaitableExecutor>(std::move(a)));
+}
+
+template <typename Executor, typename AwaitableExecutor,
+    ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr)) CompletionToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr))
+co_spawn(const Executor& ex,
+    awaitable<void, AwaitableExecutor> a, CompletionToken&& token,
+    typename enable_if<
+      (is_executor<Executor>::value || execution::is_executor<Executor>::value)
+        && is_convertible<Executor, AwaitableExecutor>::value
+    >::type*)
+{
+  return async_initiate<CompletionToken, void(std::exception_ptr)>(
+      detail::initiate_co_spawn<AwaitableExecutor>(AwaitableExecutor(ex)),
+      token, detail::awaitable_as_function<
+        void, AwaitableExecutor>(std::move(a)));
+}
+
+template <typename ExecutionContext, typename T, typename AwaitableExecutor,
+    ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr, T)) CompletionToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr, T))
+co_spawn(ExecutionContext& ctx,
+    awaitable<T, AwaitableExecutor> a, CompletionToken&& token,
+    typename enable_if<
+      is_convertible<ExecutionContext&, execution_context&>::value
+        && is_convertible<typename ExecutionContext::executor_type,
+          AwaitableExecutor>::value
+    >::type*)
+{
+  return (co_spawn)(ctx.get_executor(), std::move(a),
+      std::forward<CompletionToken>(token));
+}
+
+template <typename ExecutionContext, typename AwaitableExecutor,
+    ASIO_COMPLETION_TOKEN_FOR(
+      void(std::exception_ptr)) CompletionToken>
+inline ASIO_INITFN_AUTO_RESULT_TYPE(
+    CompletionToken, void(std::exception_ptr))
+co_spawn(ExecutionContext& ctx,
+    awaitable<void, AwaitableExecutor> a, CompletionToken&& token,
+    typename enable_if<
+      is_convertible<ExecutionContext&, execution_context&>::value
+        && is_convertible<typename ExecutionContext::executor_type,
+          AwaitableExecutor>::value
+    >::type*)
+{
+  return (co_spawn)(ctx.get_executor(), std::move(a),
+      std::forward<CompletionToken>(token));
+}
+
 template <typename Executor, typename F,
     ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
       typename result_of<F()>::type>::type) CompletionToken>
@@ -129,11 +267,11 @@ inline ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
     typename detail::awaitable_signature<typename result_of<F()>::type>::type)
 co_spawn(const Executor& ex, F&& f, CompletionToken&& token,
     typename enable_if<
-      is_executor<Executor>::value
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
     >::type*)
 {
   return async_initiate<CompletionToken,
-    typename detail::awaitable_signature<typename result_of<F()>::type>>(
+    typename detail::awaitable_signature<typename result_of<F()>::type>::type>(
       detail::initiate_co_spawn<
         typename result_of<F()>::type::executor_type>(ex),
       token, std::forward<F>(f));

data/ext/third_party/asio/asio/include/asio/impl/compose.hpp

@@ -16,11 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+#include "asio/associated_executor.hpp"
 #include "asio/detail/handler_alloc_helpers.hpp"
 #include "asio/detail/handler_cont_helpers.hpp"
 #include "asio/detail/handler_invoke_helpers.hpp"
 #include "asio/detail/type_traits.hpp"
 #include "asio/detail/variadic_templates.hpp"
+#include "asio/execution/executor.hpp"
+#include "asio/execution/outstanding_work.hpp"
 #include "asio/executor_work_guard.hpp"
 #include "asio/is_executor.hpp"
 #include "asio/system_executor.hpp"
@@ -31,6 +34,50 @@ namespace asio {
 
 namespace detail
 {
+  template <typename Executor, typename = void>
+  class composed_work_guard
+  {
+  public:
+    typedef typename decay<
+        typename prefer_result<Executor,
+          execution::outstanding_work_t::tracked_t
+        >::type
+      >::type executor_type;
+
+    composed_work_guard(const Executor& ex)
+      : executor_(asio::prefer(ex, execution::outstanding_work.tracked))
+    {
+    }
+
+    void reset()
+    {
+    }
+
+    executor_type get_executor() const ASIO_NOEXCEPT
+    {
+      return executor_;
+    }
+
+  private:
+    executor_type executor_;
+  };
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
+  template <typename Executor>
+  struct composed_work_guard<Executor,
+      typename enable_if<
+        !execution::is_executor<Executor>::value
+      >::type> : executor_work_guard<Executor>
+  {
+    composed_work_guard(const Executor& ex)
+      : executor_work_guard<Executor>(ex)
+    {
+    }
+  };
+
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
   template <typename>
   struct composed_io_executors;
 
@@ -158,7 +205,7 @@ namespace detail
     }
 
     typedef system_executor head_type;
-    executor_work_guard<system_executor> head_;
+    composed_work_guard<system_executor> head_;
   };
 
   template <typename Head>
@@ -177,7 +224,7 @@ namespace detail
     }
 
     typedef Head head_type;
-    executor_work_guard<Head> head_;
+    composed_work_guard<Head> head_;
   };
 
 #if defined(ASIO_HAS_VARIADIC_TEMPLATES)
@@ -200,7 +247,7 @@ namespace detail
     }
 
     typedef Head head_type;
-    executor_work_guard<Head> head_;
+    composed_work_guard<Head> head_;
     composed_work<void(Tail...)> tail_;
   };
 
@@ -226,7 +273,7 @@ namespace detail
     } \
   \
     typedef Head head_type; \
-    executor_work_guard<Head> head_; \
+    composed_work_guard<Head> head_; \
     composed_work<void(ASIO_VARIADIC_TARGS(n))> tail_; \
   }; \
   /**/
@@ -248,12 +295,13 @@ namespace detail
 #endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
   {
   public:
-    composed_op(ASIO_MOVE_ARG(Impl) impl,
-        ASIO_MOVE_ARG(Work) work,
-        ASIO_MOVE_ARG(Handler) handler)
-      : impl_(ASIO_MOVE_CAST(Impl)(impl)),
-        work_(ASIO_MOVE_CAST(Work)(work)),
-        handler_(ASIO_MOVE_CAST(Handler)(handler)),
+    template <typename I, typename W, typename H>
+    composed_op(ASIO_MOVE_ARG(I) impl,
+        ASIO_MOVE_ARG(W) work,
+        ASIO_MOVE_ARG(H) handler)
+      : impl_(ASIO_MOVE_CAST(I)(impl)),
+        work_(ASIO_MOVE_CAST(W)(work)),
+        handler_(ASIO_MOVE_CAST(H)(handler)),
         invocations_(0)
     {
     }
@@ -269,7 +317,10 @@ namespace detail
 #endif // defined(ASIO_HAS_MOVE)
 
     typedef typename associated_executor<Handler,
-        typename Work::head_type>::type executor_type;
+        typename composed_work_guard<
+          typename Work::head_type
+        >::executor_type
+      >::type executor_type;
 
     executor_type get_executor() const ASIO_NOEXCEPT
     {
@@ -289,7 +340,7 @@ namespace detail
     template<typename... T>
     void operator()(ASIO_MOVE_ARG(T)... t)
     {
-      if (invocations_ < ~unsigned(0))
+      if (invocations_ < ~0u)
         ++invocations_;
       impl_(*this, ASIO_MOVE_CAST(T)(t)...);
     }
@@ -304,7 +355,7 @@ namespace detail
 
     void operator()()
     {
-      if (invocations_ < ~unsigned(0))
+      if (invocations_ < ~0u)
         ++invocations_;
       impl_(*this);
     }
@@ -319,7 +370,7 @@ namespace detail
     template<ASIO_VARIADIC_TPARAMS(n)> \
     void operator()(ASIO_VARIADIC_MOVE_PARAMS(n)) \
     { \
-      if (invocations_ < ~unsigned(0)) \
+      if (invocations_ < ~0u) \
         ++invocations_; \
       impl_(*this, ASIO_VARIADIC_MOVE_ARGS(n)); \
     } \
@@ -344,19 +395,29 @@ namespace detail
   };
 
   template <typename Impl, typename Work, typename Handler, typename Signature>
-  inline void* asio_handler_allocate(std::size_t size,
+  inline asio_handler_allocate_is_deprecated
+  asio_handler_allocate(std::size_t size,
       composed_op<Impl, Work, Handler, Signature>* this_handler)
   {
+#if defined(ASIO_NO_DEPRECATED)
+    asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+    return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Impl, typename Work, typename Handler, typename Signature>
-  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+  inline asio_handler_deallocate_is_deprecated
+  asio_handler_deallocate(void* pointer, std::size_t size,
       composed_op<Impl, Work, Handler, Signature>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Impl, typename Work, typename Handler, typename Signature>
@@ -370,20 +431,28 @@ namespace detail
 
   template <typename Function, typename Impl,
       typename Work, typename Handler, typename Signature>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       composed_op<Impl, Work, Handler, Signature>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Function, typename Impl,
       typename Work, typename Handler, typename Signature>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       composed_op<Impl, Work, Handler, Signature>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Signature, typename Executors>
@@ -393,7 +462,7 @@ namespace detail
     typedef typename composed_io_executors<Executors>::head_type executor_type;
 
     template <typename T>
-    explicit initiate_composed_op(ASIO_MOVE_ARG(T) executors)
+    explicit initiate_composed_op(int, ASIO_MOVE_ARG(T) executors)
       : executors_(ASIO_MOVE_CAST(T)(executors))
     {
     }
@@ -422,21 +491,27 @@ namespace detail
   inline initiate_composed_op<Signature, Executors> make_initiate_composed_op(
       ASIO_MOVE_ARG(composed_io_executors<Executors>) executors)
   {
-    return initiate_composed_op<Signature, Executors>(
+    return initiate_composed_op<Signature, Executors>(0,
         ASIO_MOVE_CAST(composed_io_executors<Executors>)(executors));
   }
 
   template <typename IoObject>
   inline typename IoObject::executor_type
   get_composed_io_executor(IoObject& io_object,
-      typename enable_if<!is_executor<IoObject>::value>::type* = 0)
+      typename enable_if<
+        !is_executor<IoObject>::value
+          && !execution::is_executor<IoObject>::value
+      >::type* = 0)
   {
     return io_object.get_executor();
   }
 
   template <typename Executor>
   inline const Executor& get_composed_io_executor(const Executor& ex,
-      typename enable_if<is_executor<Executor>::value>::type* = 0)
+      typename enable_if<
+        is_executor<Executor>::value
+          || execution::is_executor<Executor>::value
+      >::type* = 0)
   {
     return ex;
   }
@@ -497,6 +572,30 @@ async_compose(ASIO_MOVE_ARG(Implementation) implementation,
   detail::get_composed_io_executor(ASIO_MOVE_CAST(T3)(x3)), \
   detail::get_composed_io_executor(ASIO_MOVE_CAST(T4)(x4)), \
   detail::get_composed_io_executor(ASIO_MOVE_CAST(T5)(x5))
+# define ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_6 \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T5)(x5)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T6)(x6))
+# define ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_7 \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T5)(x5)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T6)(x6)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T7)(x7))
+# define ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_8 \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T1)(x1)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T2)(x2)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T3)(x3)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T4)(x4)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T5)(x5)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T6)(x6)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T7)(x7)), \
+  detail::get_composed_io_executor(ASIO_MOVE_CAST(T8)(x8))
 
 #define ASIO_PRIVATE_ASYNC_COMPOSE_DEF(n) \
   template <typename CompletionToken, typename Signature, \
@@ -522,6 +621,9 @@ async_compose(ASIO_MOVE_ARG(Implementation) implementation,
 #undef ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_3
 #undef ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_4
 #undef ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_5
+#undef ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_6
+#undef ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_7
+#undef ASIO_PRIVATE_GET_COMPOSED_IO_EXECUTOR_8
 
 #endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
 #endif // !defined(GENERATING_DOCUMENTATION)