asioexec::completion_token & ::use_sender: Constrain Initiate

Previously async_result<asioexec::completion_token, ...>:: and
async_result<asioexec::use_sender, ...>::initiate:

- Used automatic return type deduction, and
- Were not constrained on any properties of the arguments thereto

This meant that initiating functions of the form were problematic:

  template <typename AsyncReadStream, typename Allocator,
      BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
        std::size_t)) ReadToken = default_completion_token_t<
          typename AsyncReadStream::executor_type>>
  inline auto async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
      ReadToken&& token = default_completion_token_t<
        typename AsyncReadStream::executor_type>(),
      constraint_t<
        !is_completion_condition<ReadToken>::value
      > = 0)
    -> decltype(
      async_initiate<ReadToken,
        void (boost::system::error_code, std::size_t)>(
          declval<detail::initiate_async_read_dynbuf_v1<AsyncReadStream>>(),
          token, basic_streambuf_ref<Allocator>(b), transfer_all()));

Note that:

- The above is an actual initiating function from Asio, and
- The return type is defined in terms of the type returned by
  async_initiate

The latter of the two points above means that the compiler must
determine the type of an expression involving async_initiate. Since that
expression transitively defers to async_result<...>::initiate this meant
that the compiler had to determine the return type thereof. Since (as
mentioned above) that function uses automatic return type deduction that
meant the compiler had to substitute into the body thereof. Since errors
in such a context are not SFINAE-friendly this meant that if the
variadic pack of arguments thereto did not consist only of decay-
copyable types there would be a hard compilation error (rather than the
overload simply being removed from the candidate set).

Both newly-added unit tests failed to compile before this change due to
the above.

Added a constraint to both previously-mentioned initiate functions to
address the above.

Author: RobertLeahy

include/asioexec/completion_token.hpp

@@ -527,6 +527,7 @@ namespace ASIOEXEC_ASIO_NAMESPACE {
   template <typename... Signatures>
   struct async_result<::asioexec::completion_token_t, Signatures...> {
     template <typename Initiation, typename... Args>
+      requires (std::is_constructible_v<std::decay_t<Args>, Args> && ...)
     static constexpr auto
       initiate(Initiation&& i, const ::asioexec::completion_token_t&, Args&&... args) {
       return ::asioexec::detail::completion_token::sender<

include/asioexec/use_sender.hpp

@@ -212,6 +212,7 @@ namespace ASIOEXEC_ASIO_NAMESPACE {
   template <typename... Signatures>
   struct async_result<::asioexec::use_sender_t, Signatures...> {
     template <typename Initiation, typename... Args>
+      requires(std::is_constructible_v<std::decay_t<Args>, Args> && ...)
     static constexpr auto
       initiate(Initiation&& i, const ::asioexec::use_sender_t&, Args&&... args) {
       return ::asioexec::detail::use_sender::sender(

test/asioexec/test_completion_token.cpp

@@ -997,4 +997,25 @@ namespace {
     CHECK(ctx.stopped());
   }
 
+  TEST_CASE(
+    "Substitution into async_result<completion_token, ...>::initiate is SFINAE-friendly",
+    "[asioexec][completion_token]") {
+    asio_impl::io_context ctx;
+    asio_impl::ip::tcp::socket socket(ctx);
+    asio_impl::streambuf buf;
+    //  With a SFINAE-unfriendly async_result<...>::initiate the below line doesn't compile because there's a hard compilation error trying to consider the async_read overload for dynamic buffers
+    //
+    //  See: https://github.com/NVIDIA/stdexec/issues/1684
+    auto sender = asio_impl::async_read(socket, buf, completion_token);
+    auto op = ::stdexec::connect(
+      std::move(sender) | ::stdexec::then([](const auto ec, const auto bytes_transferred) {
+        CHECK(ec);
+        CHECK(!bytes_transferred);
+      }),
+      expect_void_receiver{});
+    ::stdexec::start(op);
+    CHECK(ctx.run() != 0);
+    CHECK(ctx.stopped());
+  }
+
 } // namespace

test/asioexec/test_use_sender.cpp

@@ -250,4 +250,20 @@ namespace {
     CHECK(ctx.stopped());
   }
 
+  TEST_CASE(
+    "Substitution into async_result<use_sender, ...>::initiate is SFINAE-friendly",
+    "[asioexec][completion_token]") {
+    asio_impl::io_context ctx;
+    asio_impl::ip::tcp::socket socket(ctx);
+    asio_impl::streambuf buf;
+    //  With a SFINAE-unfriendly async_result<...>::initiate the below line doesn't compile because there's a hard compilation error trying to consider the async_read overload for dynamic buffers
+    //
+    //  See: https://github.com/NVIDIA/stdexec/issues/1684
+    auto sender = asio_impl::async_read(socket, buf, use_sender);
+    auto op = ::stdexec::connect(std::move(sender), expect_error_receiver{});
+    ::stdexec::start(op);
+    CHECK(ctx.run() != 0);
+    CHECK(ctx.stopped());
+  }
+
 } // namespace