exec::sequence: Exception Correctness

Corrected two exception-related problems with exec::sequence:

- Previously exec::sequence senders unconditionally reported that they
  could throw when connected
- Previously exec::sequence senders unconditionally reported that they
  could send set_error_t(std::exception_ptr), updated so this is now
  reported only if it's possible (i.e. if a child sender has that
  completion, or if any child sender other than the first possibly
  throws when connected)

Author: RobertLeahy

include/exec/sequence.hpp

@@ -19,6 +19,8 @@
 #include "../stdexec/__detail/__variant.hpp"
 #include "../stdexec/execution.hpp"
 
+#include <type_traits>
+
 STDEXEC_PRAGMA_PUSH()
 STDEXEC_PRAGMA_IGNORE_GNU("-Wmissing-braces")
 
@@ -54,18 +56,11 @@ namespace experimental::execution
       STDEXEC_ATTRIBUTE(host, device)
       constexpr void _start_next() noexcept
       {
-        STDEXEC_TRY
-        {
-          (*_start_next_)(this);
-        }
-        STDEXEC_CATCH_ALL
-        {
-          STDEXEC::set_error(static_cast<Rcvr&&>(_rcvr), std::current_exception());
-        }
+        (*_start_next_)(this);
       }
 
       Rcvr _rcvr;
-      void (*_start_next_)(_opstate_base*) = nullptr;
+      void (*_start_next_)(_opstate_base*) noexcept = nullptr;
     };
 
     template <class Rcvr>
@@ -120,8 +115,11 @@ namespace experimental::execution
     {
       template <class... _Ts>
       STDEXEC_ATTRIBUTE(host, device, always_inline)
-      constexpr auto
-      operator()(_Ts&&... __ts) const STDEXEC_AUTO_RETURN(_Tuple{static_cast<_Ts&&>(__ts)...});
+      constexpr _Tuple
+      operator()(_Ts&&... __ts) const noexcept(std::is_nothrow_constructible_v<_Tuple, _Ts...>)
+      {
+        return _Tuple{(_Ts&&) __ts...};
+      }
     };
 
     template <class Rcvr, class... Senders>
@@ -156,6 +154,12 @@ namespace experimental::execution
       template <class CvSndrs>
       STDEXEC_ATTRIBUTE(host, device)
       constexpr explicit _opstate(Rcvr&& rcvr, CvSndrs&& sndrs)
+        noexcept(::STDEXEC::__nothrow_connectable<
+                   decltype(::STDEXEC::__get<0>(::STDEXEC::__declval<CvSndrs>())),
+                   _rcvr_t<sizeof...(Senders) == 0>>
+                 && ::STDEXEC::__nothrow_invocable<decltype(::STDEXEC::__apply),
+                                                   __convert_tuple_fn<_senders_tuple_t>,
+                                                   CvSndrs>)
         : _opstate_base<Rcvr>{static_cast<Rcvr&&>(rcvr)}
         , _sndrs{STDEXEC::__apply(__convert_tuple_fn<_senders_tuple_t>{},
                                   static_cast<CvSndrs&&>(sndrs))}
@@ -170,19 +174,39 @@ namespace experimental::execution
       }
 
       template <std::size_t Remaining>
-      static constexpr void _start_next(_opstate_base<Rcvr>* _self)
+      static constexpr void _start_next(_opstate_base<Rcvr>* _self) noexcept
       {
-        constexpr auto __nth = sizeof...(Senders) - Remaining;
-        auto*          self  = static_cast<_opstate*>(_self);
-        auto&          sndr  = STDEXEC::__get<__nth + 1>(self->_sndrs);
-        auto&          op    = self->_ops.template __emplace_from<__nth + 1>(STDEXEC::connect,
-                                                                 std::move(sndr),
-                                                                 _rcvr_t<Remaining == 1>{self});
-        if constexpr (Remaining > 1)
+        constexpr auto __nth   = sizeof...(Senders) - Remaining;
+        auto*          self    = static_cast<_opstate*>(_self);
+        auto&          sndr    = STDEXEC::__get<__nth + 1>(self->_sndrs);
+        constexpr auto nothrow = noexcept(
+          self->_ops.template __emplace_from<__nth + 1>(STDEXEC::connect,
+                                                        std::move(sndr),
+                                                        _rcvr_t < Remaining == 1 > {self}));
+        STDEXEC_TRY
+        {
+          auto& op = self->_ops.template __emplace_from<__nth + 1>(STDEXEC::connect,
+                                                                   std::move(sndr),
+                                                                   _rcvr_t < Remaining
+                                                                     == 1 > {self});
+          if constexpr (Remaining > 1)
+          {
+            self->_start_next_ = &_start_next<Remaining - 1>;
+          }
+          STDEXEC::start(op);
+        }
+        STDEXEC_CATCH_ALL
         {
-          self->_start_next_ = &_start_next<Remaining - 1>;
+          if constexpr (nothrow)
+          {
+            STDEXEC_UNREACHABLE();
+          }
+          else
+          {
+            STDEXEC::set_error(static_cast<Rcvr&&>(static_cast<_opstate*>(_self)->_rcvr),
+                               std::current_exception());
+          }
         }
-        STDEXEC::start(op);
       }
 
       STDEXEC_ATTRIBUTE(host, device)
@@ -202,36 +226,48 @@ namespace experimental::execution
     // The completions of the sequence sender are the error and stopped completions of all the
     // child senders plus the value completions of the last child sender.
     template <class... Env>
-    struct _completions_fn
+    struct _completions_fn;
+
+    template <class Env>
+    struct _completions_fn<Env>
     {
-      // When folding left, the first sender folded will be the last sender in the list. That is
-      // also when the "state" of the fold is void. For this case we want to include the value
-      // completions; otherwise, we want to exclude them.
-      template <class State, class... Args>
+      template <bool First, bool AddExceptionPtr, class Sender>
+      static constexpr bool _add_exception_ptr =
+        AddExceptionPtr
+        || !(First || STDEXEC::__nothrow_connectable<Sender, STDEXEC::__receiver_archetype<Env>>);
+
+      // When folding left, the first sender folded will be the last sender in the list.
+      // For this case we want to include the value completions; otherwise, we want to
+      // exclude them.
+      template <bool First, bool AddExceptionPtr, class... Args>
       struct _fold_left;
 
-      template <class State, class Head, class... Tail>
-      struct _fold_left<State, Head, Tail...>
+      template <bool First, bool AddExceptionPtr, class Head, class... Tail>
+      struct _fold_left<First, AddExceptionPtr, Head, Tail...>
       {
         using __t = STDEXEC::__gather_completion_signatures_t<
-          STDEXEC::__completion_signatures_of_t<Head, Env...>,
+          STDEXEC::__completion_signatures_of_t<Head, Env>,
           STDEXEC::set_value_t,
           STDEXEC::__mconst<STDEXEC::completion_signatures<>>::__f,
           STDEXEC::__cmplsigs::__default_completion,
           STDEXEC::__mtry_q<STDEXEC::__concat_completion_signatures_t>::__f,
-          STDEXEC::__t<_fold_left<State, Tail...>>>;
+          STDEXEC::__t<
+            _fold_left<false, _add_exception_ptr<First, AddExceptionPtr, Head>, Tail...>>>;
       };
 
-      template <class Head>
-      struct _fold_left<void, Head>
+      template <bool First, bool AddExceptionPtr, class Head>
+      struct _fold_left<First, AddExceptionPtr, Head>
       {
         using __t = STDEXEC::__mtry_q<STDEXEC::__concat_completion_signatures_t>::__f<
-          STDEXEC::completion_signatures<STDEXEC::set_error_t(std::exception_ptr)>,
-          STDEXEC::__completion_signatures_of_t<Head, Env...>>;
+          std::conditional_t<
+            _add_exception_ptr<First, AddExceptionPtr, Head>,
+            STDEXEC::completion_signatures<STDEXEC::set_error_t(std::exception_ptr)>,
+            STDEXEC::completion_signatures<>>,
+          STDEXEC::__completion_signatures_of_t<Head, Env>>;
       };
 
       template <class... Sender>
-      using __f = STDEXEC::__t<_fold_left<void, Sender...>>;
+      using __f = STDEXEC::__t<_fold_left<true, false, Sender...>>;
     };
 
     template <class Sender0, class... Senders>
@@ -248,7 +284,11 @@ namespace experimental::execution
       STDEXEC_ATTRIBUTE(host, device)
       static consteval auto get_completion_signatures()
       {
-        if constexpr (STDEXEC::__decay_copyable<Self>)
+        if constexpr (sizeof...(Env) == 0)
+        {
+          return STDEXEC::__dependent_sender<Self>();
+        }
+        else if constexpr (STDEXEC::__decay_copyable<Self>)
         {
           return _completions_t<Self, Env...>{};
         }
@@ -263,6 +303,10 @@ namespace experimental::execution
       template <STDEXEC::__decay_copyable Self, class Rcvr>
       STDEXEC_ATTRIBUTE(host, device)
       constexpr STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Rcvr rcvr)
+        noexcept(std::is_nothrow_constructible_v<
+                 _opstate<Rcvr, STDEXEC::__copy_cvref_t<Self, Sender0>, Senders...>,
+                 Rcvr,
+                 decltype(((Self&&) self)._sndrs)>)
       {
         return _opstate<Rcvr, STDEXEC::__copy_cvref_t<Self, Sender0>, Senders...>{
           static_cast<Rcvr&&>(rcvr),

test/exec/test_sequence.cpp

@@ -66,6 +66,7 @@ TEST_CASE("sequence produces a sender", "[sequence]") {
   STATIC_REQUIRE(!ex::__callable<exec::sequence_t>);
 
   auto s0 = exec::sequence(ex::just(42));
+  static_assert(ex::__nothrow_connectable<decltype(s0), ex::__receiver_archetype<ex::env<>>>);
   STATIC_REQUIRE(ex::sender<decltype(s0)>);
   STATIC_REQUIRE(ex::sender_in<decltype(s0)>);
   check_val_types<ex::__mset<pack<int>>>(s0);
@@ -80,8 +81,24 @@ TEST_CASE("sequence produces a sender", "[sequence]") {
   STATIC_REQUIRE(!ex::sender_in<decltype(s1)>);
   STATIC_REQUIRE(ex::sender_in<decltype(s1), env_t>);
   check_val_types<ex::__mset<pack<const std::allocator<void>&>>, env_t>(s1);
-  check_err_types<ex::__mset<std::exception_ptr, int>, env_t>(s1);
+  check_err_types<ex::__mset<int>, env_t>(s1);
   check_sends_stopped<false, env_t>(s1);
+
+  auto s2 = exec::sequence(ex::just(), ex::just(42));
+  STATIC_REQUIRE(ex::sender<decltype(s2)>);
+  STATIC_REQUIRE(!ex::sender_in<decltype(s2)>);
+  STATIC_REQUIRE(ex::sender_in<decltype(s2), ex::env<>>);
+  check_val_types<ex::__mset<pack<int>>>(s2);
+  check_err_types<ex::__mset<>>(s2);
+  check_sends_stopped<false>(s2);
+
+  auto s3 = exec::sequence(ex::just(true), ex::just(42));
+  STATIC_REQUIRE(ex::sender<decltype(s3)>);
+  STATIC_REQUIRE(!ex::sender_in<decltype(s3)>);
+  STATIC_REQUIRE(ex::sender_in<decltype(s3), ex::env<>>);
+  check_val_types<ex::__mset<pack<int>>>(s3);
+  check_err_types<ex::__mset<>>(s3);
+  check_sends_stopped<false>(s3);
 }
 
 TEST_CASE("sequence with one argument works", "[sequence]") {
@@ -136,7 +153,16 @@ TEST_CASE("sequence with two arguments works", "[sequence]") {
 TEST_CASE("sequence with sender with throwing connect", "[sequence]") {
   auto err = std::make_exception_ptr(connect_exception{});
   auto sndr = exec::sequence(ex::just(big{}), throwing_connect{}, ex::just(big{}, 42));
+  check_err_types<ex::__mset<std::exception_ptr>, ex::env<>>(std::move(sndr));
   auto op = ex::connect(std::move(sndr), expect_error_receiver{err});
   ex::start(op);
 }
+
+TEST_CASE("sequence with sender with only first sender with throwing connect", "[sequence]")
+{
+  auto err  = std::make_exception_ptr(connect_exception{});
+  auto sndr = exec::sequence(throwing_connect{}, ex::just());
+  check_err_types<ex::__mset<>, ex::env<>>(sndr);
+  CHECK_THROWS(ex::connect(std::move(sndr), empty_recv::recv0{}));
+}
 #endif // !STDEXEC_NO_STD_EXCEPTIONS()