just: Connect Can Throw

A just sender that isn't nullary contains one or more objects. These
objects are transmitted thereinto by the sender factory therefor. Since
copying and moving objects can throw the just sender factory can also
throw (this is demonstrated by the unit test added by this commit).

In order to be useful a sender must be connected with a receiver to form
an operation state. Since the just operation does not yield the objects
passed to the sender factory therefor until the operation has been
started it is clear those objects must in turn be transmitted from the
sender to the operation state at connect time. If initially providing
those objects can throw then so too can propagating them from the sender
to the operation state. That is to say that not only can the just sender
factory throw but so too can connecting a just sender with a receiver.

Before this commit if a just sender was connected, and one of the move
operations involved therein threw an exception, the program would
terminate due to the fact the exception would attempt to pass through a
constructor marked noexcept. The code involved (changed by this commit)
attempted to accurately reflect the noexcept-ness of the operations
involved by checking:

  __noexcept_of<__sexpr_impl<__tag_t>::get_state, _Sexpr, _Receiver&>

However this merely checks if the evaluation of some function throws an
exception. In the case wherein a just sender is being connected the
evaluation does not throw and therefore the above expression correctly
yields true. The function is not merely invoked however, the value
returned thereby is used to populate a data member in the constructor
initializer list. In the instance of just the invocation yields an
rvalue reference and therefore a move operation must occur, one which
may throw an exception. To account for this the noexcept check must be:

  noexcept(__state_t(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_)))

Which is what it is changed to by this commit.

Author: RobertLeahy

include/stdexec/__detail/__basic_sender.hpp

@@ -228,7 +228,7 @@ namespace stdexec {
 
       __op_base(_Sexpr&& __sndr, _Receiver&& __rcvr) noexcept(
         __nothrow_decay_copyable<_Receiver>
-        && __noexcept_of<__sexpr_impl<__tag_t>::get_state, _Sexpr, _Receiver&>)
+        && noexcept(__state_t(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_))))
         : __rcvr_(static_cast<_Receiver&&>(__rcvr))
         , __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_)) {
       }

test/stdexec/algos/factories/test_just.cpp

@@ -19,6 +19,10 @@
 #include <test_common/receivers.hpp>
 #include <test_common/type_helpers.hpp>
 
+#include <cstddef>
+#include <stdexcept>
+#include <utility>
+
 namespace ex = stdexec;
 
 namespace {
@@ -124,4 +128,55 @@ namespace {
     CHECK(res == original);
     CHECK(cat == typecat::rvalref);
   }
+
+  TEST_CASE("just works with types with throwing move", "[factories][just]") {
+    struct throwing_move {
+      explicit throwing_move(std::size_t& throws_after) noexcept : throws_after_(throws_after) {}
+      throwing_move(throwing_move&& other)
+        : throws_after_(other.throws_after_)
+      {
+        if (throws_after_) {
+          --throws_after_;
+        } else {
+          throw std::runtime_error("Throwing as requested");
+        }
+      }
+    private:
+      std::size_t& throws_after_;
+    };
+    std::size_t throws_after = 0;
+    const auto repeat_until_succeeds = [&](auto f) noexcept -> decltype(auto) {
+      struct guard {
+        ~guard() noexcept {
+          CHECK(threw);
+        }
+        bool threw{false};
+      };
+      guard g;
+      for (;;) {
+        auto orig = throws_after;
+        try {
+          return f();
+        } catch (...) {
+          g.threw = true;
+          ++orig;
+          throws_after = orig;
+        }
+      }
+    };
+    auto sender = repeat_until_succeeds([&]() {
+      return ::stdexec::just(throwing_move(throws_after));
+    });
+    CHECK(throws_after == 0);
+    std::size_t invoked = 0;
+    auto op = repeat_until_succeeds([&]() {
+      return ::stdexec::connect(
+        std::move(sender),
+        make_fun_receiver([&](throwing_move&&) noexcept { ++invoked; }));
+    });
+    CHECK(throws_after == 0);
+    CHECK(invoked == 0);
+    ::stdexec::start(op);
+    CHECK(invoked == 1);
+  }
 } // namespace