let_value, _error, & _stopped: Use After Move On Exception From Connect

When a completion signal is sent on the appropriate completion channel
(i.e. set_value, set_error, or set_stopped) let_value, let_error, and
let_stopped (respectively):

1. Store the values associated with the signal, if any,
2. Invoke their associated invocable with those stored values, and then
3. Connect the sender returned by that invocation

Prior to this commit the implementation of the operations enumerated
above moved the final receiver into the connect operation in step 3
(more precisely those implementations moved the final receiver into a
wrapper receiver which was in turn moved into that connect operation).
This meant that if the connect operation:

1. Decay-copied the receiver (thereby moving from it), and then
2. Threw an exception

The resulting error completion signal would be sent to a receiver which
had been moved from.

Reproduced in a unit test and fixed.

Author: RobertLeahy

include/stdexec/__detail/__let.hpp

@@ -111,7 +111,7 @@ namespace stdexec {
           return __env::__join(__env_, stdexec::get_env(__rcvr_));
         }
 
-        _Receiver __rcvr_;
+        _Receiver& __rcvr_;
         const _Env2& __env_;
       };
     };
@@ -291,7 +291,7 @@ namespace stdexec {
 
       template <class _ResultSender, class _OpState>
       auto __get_result_receiver(const _ResultSender&, _OpState& __op_state) -> decltype(auto) {
-        return __rcvr_t{static_cast<_Receiver&&>(__op_state.__rcvr_), __env2_};
+        return __rcvr_t{__op_state.__rcvr_, __env2_};
       }
 
       STDEXEC_IMMOVABLE_NO_UNIQUE_ADDRESS

test/stdexec/algos/adaptors/test_let_value.cpp

@@ -24,6 +24,8 @@
 #include <exec/env.hpp>
 
 #include <chrono> // IWYU pragma: keep for chrono_literals
+#include <exception>
+#include <memory>
 
 namespace ex = stdexec;
 
@@ -347,4 +349,41 @@ namespace {
     ex::start(op);
     CHECK(completed);
   }
+
+  struct throws_on_connect {
+    using sender_concept = ::stdexec::sender_t;
+    template <typename... Args>
+    static consteval ::stdexec::completion_signatures<::stdexec::set_value_t()>
+      get_completion_signatures(const Args&...) noexcept {
+      return {};
+    }
+    template <typename Receiver>
+    auto connect(Receiver) const
+      -> ::stdexec::connect_result_t<decltype(::stdexec::just()), Receiver> {
+      throw std::logic_error("TEST");
+    }
+  };
+
+  TEST_CASE(
+    "When connecting the successor throws an exception let_value delivers an error completion "
+    "signal to a valid receiver",
+    "[adaptors][let_value]") {
+    struct receiver {
+      using receiver_concept = ::stdexec::receiver_t;
+      std::shared_ptr<int> ptr;
+      void set_value() noexcept {
+        FAIL_CHECK("Operation should end in error");
+      }
+      void set_error(std::exception_ptr ex) noexcept {
+        CHECK(ex);
+        REQUIRE(ptr);
+        *ptr = 5;
+      }
+    };
+    const auto ptr = std::make_shared<int>(0);
+    auto sender = ex::let_value(::stdexec::just(), []() noexcept { return throws_on_connect{}; });
+    auto op = ex::connect(std::move(sender), receiver{ptr});
+    ex::start(op);
+    CHECK(*ptr == 5);
+  }
 } // namespace