fix some portability issues

Author: ericniebler

include/stdexec/__detail/__as_awaitable.hpp

@@ -36,18 +36,18 @@ namespace STDEXEC {
     extern const __q<__decayed_std_tuple> __as_single;
 
     template <>
-    inline const __q<__midentity> __as_single<1>;
+    inline constexpr __q<__midentity> __as_single<1>;
 
     template <>
-    inline const __mconst<void> __as_single<0>;
+    inline constexpr __mconst<void> __as_single<0>;
 
     template <class... _Values>
     using __single_value = __minvoke<decltype(__as_single<sizeof...(_Values)>), _Values...>;
 
     template <class _Sender, class _Promise>
     using __value_t = __decay_t<
       __value_types_of_t<_Sender, env_of_t<_Promise&>, __q<__single_value>, __msingle_or<void>>
-    >;
+      >;
   } // namespace __detail
 
   /////////////////////////////////////////////////////////////////////////////

include/stdexec/__detail/__task.hpp

@@ -32,6 +32,7 @@
 #include <utility>
 
 namespace STDEXEC {
+#if !STDEXEC_NO_STD_COROUTINES()
   namespace __task {
     ////////////////////////////////////////////////////////////////////////////////
     // A base class for task::promise_type so it can be specialized when _Ty is void:
@@ -66,7 +67,7 @@ namespace STDEXEC {
       return (__total_size / __chunk_size) + (__total_size % __chunk_size != 0);
     }
 
-    struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__) __block {
+    struct alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__) __memblock {
       std::byte __storage_[__STDCPP_DEFAULT_NEW_ALIGNMENT__];
     };
 
@@ -77,10 +78,10 @@ namespace STDEXEC {
     template <class _PAlloc>
     struct __any_alloc final : __any_alloc_base {
       using value_type = std::allocator_traits<_PAlloc>::value_type;
-      static_assert(__same_as<value_type, __block>);
-      // Number of __block-sized chunks we needed store the allocator:
+      static_assert(__same_as<value_type, __memblock>);
+      // Number of __memblock-sized chunks we needed store the allocator:
       static constexpr size_t __alloc_blocks =
-        __task::__divmod(sizeof(__any_alloc), sizeof(__block));
+        __task::__divmod(sizeof(__any_alloc), sizeof(__memblock));
 
       explicit __any_alloc(_PAlloc __alloc)
         : __alloc_(std::move(__alloc)) {
@@ -91,8 +92,8 @@ namespace STDEXEC {
         // overallocated to store the allocator in the blocks immediately following the
         // promise object. We now use that allocator to deallocate the entire block of
         // memory:
-        size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__block));
-        void* const __alloc_loc = static_cast<__block*>(__ptr) + __promise_blocks;
+        size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__memblock));
+        void* const __alloc_loc = static_cast<__memblock*>(__ptr) + __promise_blocks;
 
         // Quick sanity check to make sure the allocator is where we expect it to be.
         STDEXEC_ASSERT(__alloc_loc == static_cast<void*>(this));
@@ -104,7 +105,7 @@ namespace STDEXEC {
         std::destroy_at(this);
         // Deallocate the entire block of memory:
         std::allocator_traits<_PAlloc>::deallocate(
-          __alloc, static_cast<__block*>(__ptr), __promise_blocks + __alloc_blocks);
+          __alloc, static_cast<__memblock*>(__ptr), __promise_blocks + __alloc_blocks);
       }
 
       _PAlloc __alloc_;
@@ -263,7 +264,7 @@ namespace STDEXEC {
         // If the receiver's stop token is different from the task's stop token, then we need
         // to set up a callback to request a stop on the task's stop source when the receiver's
         // stop token is triggered:
-        __callback().__construct(
+        __stop_callback().__construct(
           get_stop_token(get_env(__rcvr_)),
           __on_stopped_t{__coro_.promise().__stop_.template get<0>()});
       }
@@ -299,7 +300,7 @@ namespace STDEXEC {
       }
     }
 
-    auto __callback() noexcept -> __manual_lifetime<__stop_callback_t<_Rcvr>>&
+    auto __stop_callback() noexcept -> __manual_lifetime<__stop_callback_t<_Rcvr>>&
       requires __needs_stop_callback<_Rcvr>
     {
       return *this;
@@ -309,7 +310,7 @@ namespace STDEXEC {
       if constexpr (__needs_stop_callback<_Rcvr>) {
         // If we set up a stop callback on the receiver's stop token, then we need to
         // disable it when the operation completes:
-        __callback().__destroy();
+        __stop_callback().__destroy();
       }
 
       std::printf("opstate completed, &__errors_ = %p\n", static_cast<void*>(&this->__errors_));
@@ -338,7 +339,7 @@ namespace STDEXEC {
 
     void __canceled() noexcept final {
       if constexpr (__needs_stop_callback<_Rcvr>) {
-        __callback().__destroy();
+        __stop_callback().__destroy();
       }
 
       std::exchange(__coro_, {}).destroy();
@@ -422,14 +423,14 @@ namespace STDEXEC {
 
     template <class _Alloc, class... _Args>
     void* operator new(size_t __bytes, std::allocator_arg_t, _Alloc __alloc, _Args&&...) {
-      using __palloc_t = std::allocator_traits<_Alloc>::template rebind_alloc<__task::__block>;
+      using __palloc_t = std::allocator_traits<_Alloc>::template rebind_alloc<__task::__memblock>;
       using __pointer_t = std::allocator_traits<__palloc_t>::pointer;
       static_assert(std::is_pointer_v<__pointer_t>, "Allocator pointer type must be a raw pointer");
 
       // the number of blocks needed to store an object of type __palloc_t:
       static constexpr size_t __alloc_blocks =
-        __task::__divmod(sizeof(__task::__any_alloc<__palloc_t>), sizeof(__task::__block));
-      size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__task::__block));
+        __task::__divmod(sizeof(__task::__any_alloc<__palloc_t>), sizeof(__task::__memblock));
+      size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__task::__memblock));
 
       __palloc_t __palloc(__alloc);
       __pointer_t const __ptr =
@@ -447,8 +448,8 @@ namespace STDEXEC {
     }
 
     void operator delete(void* __ptr, size_t __bytes) noexcept {
-      size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__task::__block));
-      void* const __alloc_loc = static_cast<__task::__block*>(__ptr) + __promise_blocks;
+      size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__task::__memblock));
+      void* const __alloc_loc = static_cast<__task::__memblock*>(__ptr) + __promise_blocks;
       auto* __alloc = static_cast<__task::__any_alloc_base*>(__alloc_loc);
       __alloc->__deallocate(__ptr, __bytes);
     }
@@ -497,4 +498,5 @@ namespace STDEXEC {
     __variant_for<stop_source_type, stop_token_type> __stop_{};
     __opstate_base* __state_ = nullptr;
   };
+#endif // !STDEXEC_NO_STD_COROUTINES()
 } // namespace STDEXEC

include/stdexec/__detail/__variant.hpp

@@ -187,10 +187,10 @@ namespace STDEXEC {
 
         __destroy();
         auto __sg = __mk_index_guard(__index_, __new_index);
-        auto *__p =
+        auto *__ptr =
           std::construct_at(static_cast<_Ty *>(__get_ptr()), static_cast<_As &&>(__as)...);
         __sg.__dismiss();
-        return *std::launder(__p);
+        return *std::launder(__ptr);
       }
 
       template <std::size_t _Ny, class... _As>
@@ -201,10 +201,10 @@ namespace STDEXEC {
 
         __destroy();
         auto __sg = __mk_index_guard(__index_, _Ny);
-        auto *__p =
+        auto *__ptr =
           std::construct_at(static_cast<__at<_Ny> *>(__get_ptr()), static_cast<_As &&>(__as)...);
         __sg.__dismiss();
-        return *std::launder(__p);
+        return *std::launder(__ptr);
       }
 
       template <std::size_t _Ny, class _Fn, class... _As>
@@ -219,18 +219,18 @@ namespace STDEXEC {
         __destroy();
         auto __sg = __mk_index_guard(__index_, _Ny);
         if (std::is_constant_evaluated()) {
-          auto *__p = std::construct_at<__at<_Ny>>(
+          auto *__ptr = std::construct_at<__at<_Ny>>(
             static_cast<__at<_Ny> *>(__get_ptr()),
             STDEXEC::__emplace_from([&]() noexcept(__is_nothrow) -> decltype(auto) {
               return static_cast<_Fn &&>(__fn)(static_cast<_As &&>(__as)...);
             }));
           __sg.__dismiss();
-          return *std::launder(__p);
+          return *std::launder(__ptr);
         } else {
-          auto *__p = ::new (__get_ptr())
+          auto *__ptr = ::new (__get_ptr())
             __at<_Ny>(static_cast<_Fn &&>(__fn)(static_cast<_As &&>(__as)...));
           __sg.__dismiss();
-          return *std::launder(__p);
+          return *std::launder(__ptr);
         }
       }
 

test/stdexec/types/test_task.cpp

@@ -15,16 +15,21 @@
  * limitations under the License.
  */
 
-#include <stdexec/execution.hpp>
+#include <stdexec/coroutine.hpp>
 
-#include <exec/single_thread_context.hpp>
-#include <stdexec/__detail/__task.hpp>
+#if !STDEXEC_NO_STD_COROUTINES()
 
-#include <atomic>
+#  include <stdexec/execution.hpp>
 
-#include <catch2/catch.hpp>
+#  include <exec/single_thread_context.hpp>
+#  include <stdexec/__detail/__task.hpp>
 
-#include <test_common/allocators.hpp>
+#  include <atomic>
+
+#  include <catch2/catch.hpp>
+
+#  include <test_common/allocators.hpp>
+#  include <test_common/senders.hpp>
 
 namespace ex = STDEXEC;
 
@@ -135,6 +140,24 @@ namespace {
     CHECK(!res.has_value());
   }
 
+  auto test_task_awaits_just_ref_sender() -> ex::task<void> {
+    int value = 42;
+    [[maybe_unused]]
+    decltype(auto) value_ref = co_await just_ref(value);
+    // BUGBUG TODO: references are not supported yet so just check that we get the right value back for now
+    CHECK(value_ref == 42);
+    // STATIC_REQUIRE(std::same_as<decltype(value_ref), int&>);
+    // CHECK(&value_ref == &value);
+    co_return;
+  }
+
+  TEST_CASE("test task can await a just_ref sender", "[types][task]") {
+    auto t = test_task_awaits_just_ref_sender();
+    ex::sync_wait(std::move(t));
+  }
+
   // TODO: add tests for stop token support in task
 
 } // anonymous namespace
+
+#endif // !STDEXEC_NO_STD_COROUTINES()

test/test_common/senders.hpp

@@ -252,5 +252,44 @@ namespace {
     std::shared_ptr<std::atomic<int>> counter_;
   };
 
+  // A sender that sends by reference
+  template <class Type>
+  struct just_ref {
+    using sender_concept = ex::sender_t;
+
+    explicit just_ref(Type& value)
+      : value_(value) {
+    }
+
+    template <class>
+    static consteval auto get_completion_signatures() noexcept {
+      return ex::completion_signatures<ex::set_value_t(Type&)>{};
+    }
+
+    template <class Receiver>
+    auto connect(Receiver rcvr) const noexcept {
+      return opstate{value_, static_cast<Receiver&&>(rcvr)};
+    }
+
+   private:
+    template <class Receiver>
+    struct opstate {
+      using operation_state_concept = ex::operation_state_t;
+
+      explicit opstate(Type& value, Receiver rcvr)
+        : value_(value)
+        , rcvr_(std::move(rcvr)) {
+      }
+
+      void start() noexcept {
+        ex::set_value(static_cast<Receiver&&>(rcvr_), value_);
+      }
+
+      Type& value_;
+      Receiver rcvr_;
+    };
+
+    Type& value_;
+  };
 
 } // namespace