Merge pull request #35 from beman-project/fix-forwarding-env

Fix forwarding env

Author: dietmarkuehl

examples/CMakeLists.txt

@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # cmake-format: on
 
-set(BEMAN_EXECUTION26_LIBRARY beman_execution26)
-
-include(GNUInstallDirs)
+set(BEMAN_EXECUTION26_LIBRARY beman_${TARGET_NAME})
 
 set(EXAMPLES
   stop_token

include/beman/execution26/detail/common.hpp

@@ -25,4 +25,14 @@
 
 // ----------------------------------------------------------------------------
 
+namespace beman::execution26::detail
+{
+    template <typename...> struct fail_type;
+    template <typename...T>
+    auto fail(T&&...) { fail_type<T...>{}; }
+    auto use(auto&&...) noexcept -> void {}
+}
+
+// ----------------------------------------------------------------------------
+
 #endif

include/beman/execution26/detail/completion_signatures_of_t.hpp

@@ -14,7 +14,7 @@
 namespace beman::execution26
 {
     template <typename Sender, typename Env = ::beman::execution26::empty_env>
-        requires ::beman::execution26::sender_in<Sender>
+        requires ::beman::execution26::sender_in<Sender, Env>
     using completion_signatures_of_t
         = ::beman::execution26::detail::call_result_t<
             ::beman::execution26::get_completion_signatures_t, Sender, Env

include/beman/execution26/detail/fwd_env.hpp

@@ -28,12 +28,13 @@ namespace beman::execution26::detail
             = BEMAN_EXECUTION26_DELETE("the used query is not forwardable");
 
         template <typename Query, typename... Args>
-            requires (::beman::execution26::forwarding_query(::std::remove_cvref_t<Query>()))
+            requires(::beman::execution26::forwarding_query(::std::remove_cvref_t<Query>()))
             && requires(Env const& env, Query&& q, Args&&... args)
             {
                 env.query(q, ::std::forward<Args>(args)...);
             }
         constexpr auto query(Query&& q, Args&&... args) const
+            noexcept(noexcept(env.query(q, ::std::forward<Args>(args)...)))
         {
             return env.query(q, ::std::forward<Args>(args)...);
         }

include/beman/execution26/detail/into_variant.hpp

@@ -15,7 +15,6 @@
 #include <beman/execution26/detail/make_sender.hpp>
 #include <beman/execution26/detail/meta_combine.hpp>
 #include <beman/execution26/detail/sender.hpp>
-#include <beman/execution26/detail/sender_in.hpp>
 #include <beman/execution26/detail/sends_stopped.hpp>
 #include <beman/execution26/detail/set_error.hpp>
 #include <beman/execution26/detail/set_value.hpp>

src/beman/execution26/CMakeLists.txt

@@ -1,5 +1,5 @@
 # cmake-format: off
-# src/beman/${TARGET_NAME}/CMakeLists.txt -*-makefile-*-
+# src/beman/execution26/CMakeLists.txt -*-makefile-*-
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # cmake-format: on
 

src/beman/execution26/tests/exec-into-variant.pass.cpp

@@ -18,8 +18,6 @@
 
 namespace
 {
-    auto use(auto&&...) {}
-
     struct non_sender {};
     struct sender
     {
@@ -80,7 +78,6 @@ namespace
             assert(not called);
             op.start();
             assert(called);
-            use(op);
         }
     }
 

src/beman/execution26/tests/exec-snd-expos.pass.cpp

@@ -39,8 +39,6 @@
 
 namespace
 {
-    auto use(auto&&...) {}
-
     struct domain
     {
         int value{};
@@ -972,22 +970,22 @@ namespace
             test_detail::basic_state state{std::move(s), receiver{}};
             auto product{test_detail::connect_all(&state, std::move(s), std::index_sequence<>{})};
             assert(product.size() == 0);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             sender0 const s{};
             test_detail::basic_state state{std::move(s), receiver{}};
             auto product{test_detail::connect_all(&state, std::move(s), std::index_sequence<>{})};
             assert(product.size() == 0);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             static_assert(requires{ sender1{}.connect(receiver{}); });
             static_assert(requires{ test_std::connect(sender1{}, receiver{}); });
             test_detail::basic_state state{sender1{}, receiver{}};
             auto product{test_detail::connect_all(&state, sender1{}, std::index_sequence<0>{})};
             assert(product.size() == 1);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             sender1 const s{};
@@ -996,15 +994,15 @@ namespace
             test_detail::basic_state state{std::move(s), receiver{}};
             auto product{test_detail::connect_all(&state, std::move(s), std::index_sequence<0>{})};
             assert(product.size() == 1);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             static_assert(requires{ sender2{}.connect(receiver{}); });
             static_assert(requires{ test_std::connect(sender2{}, receiver{}); });
             test_detail::basic_state state{sender2{}, receiver{}};
             auto product{test_detail::connect_all(&state, sender2{}, std::index_sequence<0, 1>{})};
             assert(product.size() == 2);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             sender2 const s{};
@@ -1013,15 +1011,15 @@ namespace
             test_detail::basic_state state{std::move(s), receiver{}};
             auto product{test_detail::connect_all(&state, std::move(s), std::index_sequence<0, 1>{})};
             assert(product.size() == 2);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             static_assert(requires{ sender3{}.connect(receiver{}); });
             static_assert(requires{ test_std::connect(sender3{}, receiver{}); });
             test_detail::basic_state state{sender3{}, receiver{}};
             auto product{test_detail::connect_all(&state, sender3{}, std::index_sequence<0, 1, 2>{})};
             assert(product.size() == 3);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             sender3 const s{};
@@ -1030,15 +1028,15 @@ namespace
             test_detail::basic_state state{std::move(s), receiver{}};
             auto product{test_detail::connect_all(&state, std::move(s), std::index_sequence<0, 1, 2>{})};
             assert(product.size() == 3);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             static_assert(requires{ sender4{}.connect(receiver{}); });
             static_assert(requires{ test_std::connect(sender4{}, receiver{}); });
             test_detail::basic_state state{sender4{}, receiver{}};
             auto product{test_detail::connect_all(&state, sender4{}, std::index_sequence<0, 1, 2, 3>{})};
             assert(product.size() == 4);
-            use(product);
+            test_std::detail::use(product);
         }
         {
             sender4 const s{};
@@ -1047,7 +1045,7 @@ namespace
             test_detail::basic_state state{std::move(s), receiver{}};
             auto product{test_detail::connect_all(&state, std::move(s), std::index_sequence<0, 1, 2, 3>{})};
             assert(product.size() == 4);
-            use(product);
+            test_std::detail::use(product);
         }
 
         //-dk: TODO test connect_all
@@ -1197,9 +1195,9 @@ namespace
 
         {
             auto&&[a, b, c] = tagged_sender{basic_sender_tag{}, data{}, sender0{}};
-            use(a);
-            use(b);
-            use(c);
+            test_std::detail::use(a);
+            test_std::detail::use(b);
+            test_std::detail::use(c);
             static_assert(std::same_as<basic_sender_tag, std::remove_cvref_t<decltype(a)>>);
         }
 
@@ -1222,10 +1220,10 @@ namespace
 
         basic_sender bs{basic_sender_tag{}, data{}, sender0 {}};
         basic_sender const& cbs{bs};
-        use(cbs);
+        test_std::detail::use(cbs);
 
         auto&&[tag, data, children] = test_detail::get_sender_data(bs);
-        use(tag, data, children);
+        test_std::detail::use(tag, data, children);
         static_assert(std::same_as<basic_sender_tag, std::remove_cvref_t<decltype(tag)>>);
 
         static_assert(std::same_as<
@@ -1250,14 +1248,14 @@ namespace
 #endif
 
         auto ge{test_std::get_env(bs)};
-        use(ge);
+        test_std::detail::use(ge);
         static_assert(std::same_as<
             test_detail::fwd_env<sender0::env>,
             decltype(ge)
         >);
 
         auto op{test_std::connect(bs, receiver{})};
-        use(op);
+        test_std::detail::use(op);
 #if 0
         static_assert(std::same_as<
             basic_sender_tag::sender::completion_signatures,
@@ -1442,7 +1440,7 @@ namespace
         auto we_op{test_std::connect(we_sender, write_env_receiver{&has_both_properties})};
         we_op.start();
         assert(has_both_properties);
-        use(we_op);
+        test_std::detail::use(we_op);
     }
 
     template <typename... T>