Get exception ptr CPO

examples/linux/file_coroutines_test.cpp

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unifex/config.hpp>
+
+// requires both coroutine and liburing support (for now)
+#if !UNIFEX_NO_COROUTINES and !UNIFEX_NO_LIBURING
+#  include <unifex/linux/io_uring_context.hpp>
+using io_context = unifex::linuxos::io_uring_context;
+
+#  include <unifex/sync_wait.hpp>
+#  include <unifex/task.hpp>
+
+using namespace unifex;
+
+int main() {
+  io_context ctx{};
+  auto sched = ctx.get_scheduler();
+  inplace_stop_source stopSource;
+  std::thread t{[&] {
+    ctx.run(stopSource.get_token());
+  }};
+  scope_guard stopOnExit = [&]() noexcept {
+    stopSource.request_stop();
+    t.join();
+  };
+  sync_wait([&]() -> task<void> {
+    auto file = open_file_write_only(
+        sched, filesystem::path{"file_coroutine_test.txt"});
+    constexpr char hello[]{"hello\n"};
+    size_t offset = 0;
+    for (int ii = 0; ii < 42; ++ii) {
+      offset += co_await async_write_some_at(
+          file, offset, as_bytes(span{hello, sizeof(hello) - 1}));
+    }
+    std::printf("wrote %zu bytes\n", offset);
+  }());
+  return 0;
+}
+#else
+#  include <cstdio>
+int main() {
+  printf("neither io_uring or coroutine support found\n");
+  return 0;
+}
+#endif

include/unifex/as_exception_ptr.hpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <unifex/exception.hpp>
+#include <unifex/tag_invoke.hpp>
+#include <unifex/type_traits.hpp>
+
+#include <memory>
+#include <system_error>
+
+#include <unifex/detail/prologue.hpp>
+
+namespace unifex
+{
+  namespace _as_exception_ptr
+  {
+    inline constexpr struct _fn {
+      // forward std::exception_ptr
+      std::exception_ptr operator()(std::exception_ptr eptr) const noexcept {
+        return eptr;
+      }
+
+      // convert std::exception based types to std::exception_ptr
+      template(typename Exception)
+          (requires std::is_base_of_v<std::exception, Exception>)
+      std::exception_ptr operator()(Exception&& ex) const noexcept {
+        return make_exception_ptr(std::forward<Exception>(ex));
+      }
+
+      // use customization point
+      // to resolve ErrorCode -> std::exception_ptr conversion
+      template(typename ErrorCode)
+          (requires nothrow_tag_invocable<_fn, ErrorCode>)
+      std::exception_ptr operator()(ErrorCode&& error) const noexcept {
+        return tag_invoke(*this, std::forward<ErrorCode>(error));
+      }
+    } as_exception_ptr{};
+
+    // default std::error_code -> std::exception_ptr conversion
+    inline std::exception_ptr
+    tag_invoke(tag_t<as_exception_ptr>, std::error_code&& error) noexcept {
+      return make_exception_ptr(
+          std::system_error{std::forward<std::error_code>(error)});
+    }
+
+  }  // namespace _as_exception_ptr
+
+  using _as_exception_ptr::as_exception_ptr;
+}  // namespace unifex
+
+#include <unifex/detail/epilogue.hpp>

include/unifex/receiver_concepts.hpp

@@ -20,6 +20,7 @@
 #include <unifex/type_traits.hpp>
 #include <unifex/std_concepts.hpp>
 #include <unifex/detail/unifex_fwd.hpp>
+#include <unifex/as_exception_ptr.hpp>
 
 #include <exception>
 #include <type_traits>
@@ -116,14 +117,25 @@ namespace _rec_cpo {
           _set_error_fn{}, (Receiver &&) r, (Error&&) error);
     }
     template(typename Receiver, typename Error)
-      (requires (!tag_invocable<_set_error_fn, Receiver, Error>))
+      (requires (!tag_invocable<_set_error_fn, Receiver, Error>) &&
+         (!tag_invocable<decltype(as_exception_ptr), Error>))
     auto operator()(Receiver&& r, Error&& error) const noexcept
         -> _result_t<Receiver, Error> {
       static_assert(
           noexcept(static_cast<Receiver&&>(r).set_error((Error &&) error)),
           "receiver.set_error() method must be nothrow invocable");
       return static_cast<Receiver&&>(r).set_error((Error&&) error);
     }
+    template(typename Receiver, typename Error)
+      (requires (!tag_invocable<_set_error_fn, Receiver, Error>) &&
+         tag_invocable<decltype(as_exception_ptr), Error>)
+    auto operator()(Receiver&& r, Error&& error) const noexcept
+    -> _result_t<Receiver, std::exception_ptr> {
+      static_assert(
+          noexcept(static_cast<Receiver&&>(r).set_error(as_exception_ptr((Error&&) error))),
+          "receiver.set_error() method must be nothrow invocable");
+      return static_cast<Receiver&&>(r).set_error(as_exception_ptr((Error&&) error));
+    }
   } set_error{};
 
   inline const struct _set_done_fn {

include/unifex/sync_wait.hpp

@@ -15,14 +15,15 @@
  */
 #pragma once
 
+#include <unifex/as_exception_ptr.hpp>
+#include <unifex/bind_back.hpp>
+#include <unifex/blocking.hpp>
+#include <unifex/exception.hpp>
 #include <unifex/manual_event_loop.hpp>
 #include <unifex/manual_lifetime.hpp>
 #include <unifex/scheduler_concepts.hpp>
 #include <unifex/sender_concepts.hpp>
-#include <unifex/blocking.hpp>
 #include <unifex/with_query_value.hpp>
-#include <unifex/bind_back.hpp>
-#include <unifex/exception.hpp>
 
 #include <condition_variable>
 #include <exception>
@@ -83,15 +84,6 @@ struct _receiver {
       signal_complete();
     }
 
-    void set_error(std::error_code ec) && noexcept {
-      std::move(*this).set_error(make_exception_ptr(std::system_error{ec, "sync_wait"}));
-    }
-
-    template <typename Error>
-    void set_error(Error&& e) && noexcept {
-      std::move(*this).set_error(make_exception_ptr((Error&&)e));
-    }
-
     void set_done() && noexcept {
       promise_.state_ = promise<T>::state::done;
       signal_complete();

include/unifex/tag_invoke.hpp

@@ -101,8 +101,11 @@ namespace unifex {
 
   template <typename CPO, typename... Args>
   UNIFEX_CONCEPT tag_invocable =
-      (sizeof(_tag_invoke::try_tag_invoke<CPO, Args...>(0)) ==
-       sizeof(_tag_invoke::yes_type));
+      (is_tag_invocable_v<CPO, Args...>);
+
+  template <typename CPO, typename... Args>
+  UNIFEX_CONCEPT nothrow_tag_invocable =
+      (is_nothrow_tag_invocable_v<CPO, Args...>);
 
   template <typename Fn>
   using meta_tag_invoke_result =

test/as_exception_ptr_test.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unifex/as_exception_ptr.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace unifex;
+
+TEST(as_exception_ptr, error_code) {
+  try {
+    std::rethrow_exception(
+        as_exception_ptr(std::make_error_code(std::errc::not_supported)));
+  } catch (std::system_error& ex) {
+    EXPECT_EQ(ex.code(), std::errc::not_supported);
+  }
+}
+
+struct test_error {
+  int error_code;
+
+  friend std::exception_ptr tag_invoke(tag_t<as_exception_ptr>, test_error&& error) noexcept {
+    return std::make_exception_ptr(
+        std::runtime_error(std::to_string(std::forward<test_error>(error).error_code)));
+  }
+};
+
+TEST(as_exception_ptr, custom_error) {
+  try {
+    std::rethrow_exception(as_exception_ptr(test_error{42}));
+  } catch (std::runtime_error& ex) {
+    EXPECT_EQ(ex.what(), std::string_view{"42"});
+  }
+}