avoid instantiating default sync_wait impl needlessly

Author: ericniebler

include/nvexec/stream/sync_wait.cuh

@@ -19,6 +19,8 @@
 #pragma once
 
 #include "../../stdexec/execution.hpp"
+#include "common.cuh"
+
 #include <concepts>
 #include <exception>
 #include <new>
@@ -27,8 +29,6 @@
 #include <utility>
 #include <variant>
 
-#include "common.cuh"
-
 namespace nvexec::_strm {
   namespace _sync_wait {
     struct __env {

include/stdexec/__detail/__basic_sender.hpp

@@ -135,6 +135,8 @@ namespace STDEXEC {
           static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr)};
       };
 
+      static constexpr auto submit = []{};
+
       static constexpr auto start = []<class _StartTag = start_t, class... _ChildOps>(
                                       __ignore,
                                       __ignore,
@@ -435,10 +437,6 @@ namespace STDEXEC {
 
   using __detail::__enable_receiver_from_this;
 
-  template <class _Tag>
-  using __get_attrs_fn =
-    __result_of<__detail::__drop_front, __mtypeof<__sexpr_impl<_Tag>::get_attrs>>;
-
   //! A dummy type used only for diagnostic purposes.
   //! See `__sexpr` for the implementation of P2300's _`basic-sender`_.
   template <class...>
@@ -463,19 +461,15 @@ namespace STDEXEC {
       using __desc_t = decltype(_DescriptorFn());
       using __tag_t = __desc_t::__tag;
 
-      template <class _Self>
-      using __impl = __sexpr_impl<__meval<__msecond, _Self, __tag_t>>;
-
-      template <class _Self = __sexpr>
-      STDEXEC_ATTRIBUTE(always_inline)
-      auto get_env() const noexcept -> decltype(auto) {
-        return __apply(__detail::__drop_front(__impl<_Self>::get_attrs), *this);
+      STDEXEC_ATTRIBUTE(nodiscard, always_inline)
+      constexpr auto get_env() const noexcept -> decltype(auto) {
+        return __apply(__detail::__drop_front(__sexpr_impl<__tag_t>::get_attrs), *this);
       }
 
       template <class _Self, class... _Env>
       static consteval auto get_completion_signatures() {
         static_assert(__decays_to_derived_from<_Self, __sexpr>);
-        using __impl_t = __mtypeof<__impl<_Self>::get_completion_signatures>;
+        using __impl_t = __mtypeof<__sexpr_impl<__tag_t>::get_completion_signatures>;
         using __detail::__has_static_consteval_get_completion_signatures;
 
         if constexpr (__has_static_consteval_get_completion_signatures<__tag_t, _Self, _Env...>) {
@@ -489,30 +483,42 @@ namespace STDEXEC {
         }
       }
 
+      // Non-standard extension:
       template <class _Self, receiver _Receiver>
-      STDEXEC_ATTRIBUTE(always_inline)
-      STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this _Self&& __self, _Receiver&& __rcvr)
-        noexcept(__noexcept_of<__impl<_Self>::connect, _Self, _Receiver>)
-      // -> __msecond<
-      //   __enable_if<__decays_to_derived_from<_Self, __sexpr>>,
-      //   __result_of<__impl<_Self>::connect, _Self, _Receiver>
-      // >
-      {
+      STDEXEC_ATTRIBUTE(nodiscard, always_inline)
+      static constexpr auto static_connect(_Self&& __self, _Receiver __rcvr)
+        noexcept(__noexcept_of<__sexpr_impl<__tag_t>::connect, _Self, _Receiver>)
+          -> __result_of<__sexpr_impl<__tag_t>::connect, _Self, _Receiver> {
         static_assert(__decays_to_derived_from<_Self, __sexpr>);
-        return __impl<_Self>::connect(
+        return __sexpr_impl<__tag_t>::connect(
           static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
       }
-      STDEXEC_EXPLICIT_THIS_END(connect)
+
+      template <receiver _Receiver>
+      STDEXEC_ATTRIBUTE(nodiscard, always_inline)
+      constexpr auto connect(_Receiver __rcvr) && noexcept(
+        __noexcept_of<__sexpr_impl<__tag_t>::connect, __sexpr, _Receiver>)
+        -> __result_of<__sexpr_impl<__tag_t>::connect, __sexpr, _Receiver> {
+        return __sexpr_impl<__tag_t>::connect(
+          static_cast<__sexpr&&>(*this), static_cast<_Receiver&&>(__rcvr));
+      }
+
+      template <receiver _Receiver>
+        requires __std::copy_constructible<__sexpr>
+      STDEXEC_ATTRIBUTE(nodiscard, always_inline)
+      constexpr auto connect(_Receiver __rcvr) const & noexcept(
+        __noexcept_of<__sexpr_impl<__tag_t>::connect, __sexpr const &, _Receiver>)
+        -> __result_of<__sexpr_impl<__tag_t>::connect, __sexpr const &, _Receiver> {
+        return __sexpr_impl<__tag_t>::connect(*this, static_cast<_Receiver&&>(__rcvr));
+      }
 
       template <class _Self, receiver _Receiver>
-      STDEXEC_ATTRIBUTE(always_inline)
-      static auto submit(_Self&& __self, _Receiver&& __rcvr)
-        noexcept(__noexcept_of<__impl<_Self>::submit, _Self, _Receiver>) -> __msecond<
-          __enable_if<__decays_to_derived_from<_Self, __sexpr>>,
-          __result_of<__impl<_Self>::submit, _Self, _Receiver>
-        > {
+      STDEXEC_ATTRIBUTE(nodiscard, always_inline)
+      static constexpr auto submit(_Self&& __self, _Receiver __rcvr)
+        noexcept(__noexcept_of<__sexpr_impl<__tag_t>::submit, _Self, _Receiver>)
+          -> __result_of<__sexpr_impl<__tag_t>::submit, _Self, _Receiver> {
         static_assert(__decays_to_derived_from<_Self, __sexpr>);
-        return __impl<_Self>::submit(
+        return __sexpr_impl<__tag_t>::submit(
           static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
       }
     };

include/stdexec/__detail/__sync_wait.hpp

@@ -62,11 +62,6 @@ namespace STDEXEC {
       constexpr auto query(__root_t) const noexcept -> bool {
         return true;
       }
-
-      // static constexpr auto query(__debug::__is_debug_env_t) noexcept -> bool
-      // {
-      //   return true;
-      // }
     };
 
     // What should sync_wait(just_stopped()) return?
@@ -99,8 +94,8 @@ namespace STDEXEC {
         std::optional<std::tuple<_Values...>>* __values_;
 
         template <class... _As>
-          requires __std::constructible_from<std::tuple<_Values...>, _As...>
         void set_value(_As&&... __as) noexcept {
+          static_assert(__std::constructible_from<std::tuple<_Values...>, _As...>);
           STDEXEC_TRY {
             __values_->emplace(static_cast<_As&&>(__as)...);
           }
@@ -192,60 +187,61 @@ namespace STDEXEC {
     ////////////////////////////////////////////////////////////////////////////
     // [execution.senders.consumers.sync_wait]
     struct sync_wait_t {
-      template <class _Sender>
+      template <sender_in<__env> _Sender>
       auto operator()(_Sender&& __sndr) const {
-        if constexpr (!sender_in<_Sender, __env>) {
-          STDEXEC::__diagnose_sender_concept_failure<_Sender, __env>();
-        } else {
-          using __domain_t = __completion_domain_of_t<set_value_t, _Sender, __env>;
-          constexpr auto __success_completion_count =
-            __count_of<set_value_t, _Sender, __env>::value;
-
-          static_assert(
-            __success_completion_count != 0,
-            "The argument to STDEXEC::sync_wait() is a sender that cannot complete successfully. "
-            "STDEXEC::sync_wait() requires a sender that can complete successfully in exactly one "
-            "way. In other words, the sender's completion signatures must include exactly one "
-            "signature of the form `set_value_t(value-types...)`.");
-
-          static_assert(
-            __success_completion_count <= 1,
-            "The sender passed to STDEXEC::sync_wait() can complete successfully in "
-            "more than one way. Use STDEXEC::sync_wait_with_variant() instead.");
-
-          if constexpr (1 == __success_completion_count) {
-            using __sync_wait_receiver = __receiver_t<_Sender>;
-            constexpr bool __no_custom_sync_wait = __same_as<__domain_t, default_domain>;
-            if constexpr (__no_custom_sync_wait && sender_to<_Sender, __sync_wait_receiver>) {
-              // using __connect_result = connect_result_t<_Sender, __sync_wait_receiver>;
-              // if constexpr (!operation_state<__connect_result>) {
-              //   static_assert(
-              //     operation_state<__connect_result>,
-              //     "The `connect` member function of the sender passed to STDEXEC::sync_wait() does "
-              //     "not return an operation state. An operation state is required to have a "
-              //     "no-throw .start() member function.");
-              // } else
-              {
+        using __domain_t = __completion_domain_of_t<set_value_t, _Sender, __env>;
+        constexpr auto __success_completion_count = __count_of<set_value_t, _Sender, __env>::value;
+
+        static_assert(
+          __success_completion_count != 0,
+          "The argument to STDEXEC::sync_wait() is a sender that cannot complete successfully. "
+          "STDEXEC::sync_wait() requires a sender that can complete successfully in exactly one "
+          "way. In other words, the sender's completion signatures must include exactly one "
+          "signature of the form `set_value_t(value-types...)`.");
+
+        static_assert(
+          __success_completion_count <= 1,
+          "The sender passed to STDEXEC::sync_wait() can complete successfully in "
+          "more than one way. Use STDEXEC::sync_wait_with_variant() instead.");
+
+        if constexpr (1 == __success_completion_count) {
+          if constexpr (__same_as<__domain_t, default_domain>) {
+            if constexpr (sender_to<_Sender, __receiver_t<_Sender>>) {
+              using __opstate_t = connect_result_t<_Sender, __receiver_t<_Sender>>;
+              if constexpr (operation_state<__opstate_t>) {
                 // success path, dispatch to the default domain's sync_wait
                 return default_domain().apply_sender(*this, static_cast<_Sender&&>(__sndr));
+              } else {
+                static_assert(
+                  operation_state<__opstate_t>,
+                  "The `connect` member function of the sender passed to STDEXEC::sync_wait() "
+                  "does not return an operation state. An operation state is required to have a "
+                  "no-throw .start() member function.");
               }
-            } else if constexpr (__no_custom_sync_wait) {
+            } else {
               static_assert(
-                sender_to<_Sender, __sync_wait_receiver>,
+                sender_to<_Sender, __receiver_t<_Sender>>,
                 STDEXEC_ERROR_SYNC_WAIT_CANNOT_CONNECT_SENDER_TO_RECEIVER);
-            } else if constexpr (!__has_implementation_for<sync_wait_t, __domain_t, _Sender>) {
-              static_assert(
-                __has_implementation_for<sync_wait_t, __domain_t, _Sender>,
-                "The sender passed to STDEXEC::sync_wait() has a domain that does not provide a "
-                "usable implementation for sync_wait().");
-            } else {
-              // success path, dispatch to the custom domain's sync_wait
-              return STDEXEC::apply_sender(__domain_t(), *this, static_cast<_Sender&&>(__sndr));
             }
+          } else if constexpr (!__has_implementation_for<sync_wait_t, __domain_t, _Sender>) {
+            static_assert(
+              __has_implementation_for<sync_wait_t, __domain_t, _Sender>,
+              "The sender passed to STDEXEC::sync_wait() has a domain that does not provide a "
+              "usable implementation for sync_wait().");
+          } else {
+            // success path, dispatch to the custom domain's sync_wait
+            return STDEXEC::apply_sender(__domain_t(), *this, static_cast<_Sender&&>(__sndr));
           }
         }
       }
 
+      template <class _Sender>
+      auto operator()(_Sender&&) const {
+        STDEXEC::__diagnose_sender_concept_failure<_Sender, __env>();
+        // dummy return type to silence follow-on errors
+        return std::optional<std::tuple<int>>{};
+      }
+
       // clang-format off
       /// @brief Synchronously wait for the result of a sender, blocking the
       ///         current thread.