result_catch_all captures invocation exceptions in result<T>

Reviewed By: ispeters, ibrahimjirdeh

Differential Revision: D71942890

fbshipit-source-id: 3f35c8cdd35b4a1061eae0694b0e0e5f2c5633fc

Author: snarkmaster

folly/result/result.h

@@ -903,6 +903,37 @@ auto /* implicit */ operator co_await(T && t) {
   return detail::result_co_await_dispatcher()(std::forward<T>(t));
 }
 
+/// Wraps the return value from the lambda `fn` in a `result`, putting any
+/// thrown exception into its "error" state.
+///
+///   return result_catch_all([&](){ return riskyWork(); });
+///
+/// Useful when you need a subroutine **definitely** not to throw. In contrast:
+///   - `result<>` coroutines catch unhandled exceptions, but can throw due to
+///     argument copy/move ctors, or due to `bad_alloc`.
+///   - Like all functions, `result<>` non-coroutines let exceptions fly.
+template <typename F>
+// Wrap the return type of `fn` with `result` unless it already is `result`.
+typename std::conditional_t<
+    is_instantiation_of_v<result, std::invoke_result_t<F>>,
+    std::invoke_result_t<F>,
+    result<std::invoke_result_t<F>>>
+result_catch_all(F&& fn) noexcept {
+  try {
+    if constexpr (std::is_void_v<std::invoke_result_t<F>>) {
+      static_cast<F&&>(fn)();
+      return {};
+    } else {
+      return static_cast<F&&>(fn)();
+    }
+  } catch (...) {
+    // We're a making `result`, so it's OK to forward all exceptions into it,
+    // including `OperationCancelled`.
+    return non_value_result::make_legacy_error_or_cancellation(
+        exception_wrapper{std::current_exception()});
+  }
+}
+
 } // namespace folly
 
 #endif // FOLLY_HAS_RESULT

folly/result/test/result_test.cpp

@@ -876,6 +876,47 @@ RESULT_CO_TEST_F(ResultTest, check_TEST_F) {
   EXPECT_EQ(co_await std::ref(r), 42);
 }
 
+TEST(Result, catch_all_returns_result_error) {
+  auto res = []() -> result<uint8_t> {
+    return result_catch_all([]() -> result<uint8_t> {
+      return make_exception_wrapper<std::logic_error>("bop");
+    });
+  }();
+  ASSERT_STREQ("bop", get_exception<std::logic_error>(res)->what());
+}
+
+TEST(Result, catch_all_throws_error) {
+  auto res = []() -> result<uint8_t> {
+    return result_catch_all([]() -> uint8_t {
+      throw std::logic_error("foobar");
+    });
+  }();
+  ASSERT_STREQ("foobar", get_exception<std::logic_error>(res)->what());
+}
+
+TEST(Result, catch_all_throws_error_returns_result) {
+  auto res = []() -> result<uint8_t> {
+    return result_catch_all([]() -> result<uint8_t> {
+      throw std::logic_error("foobar");
+    });
+  }();
+  ASSERT_STREQ("foobar", get_exception<std::logic_error>(res)->what());
+}
+
+TEST(Result, catch_all_void_throws_error) {
+  auto res = []() -> result<> {
+    return result_catch_all([]() { throw std::logic_error("baz"); });
+  }();
+  ASSERT_STREQ("baz", get_exception<std::logic_error>(res)->what());
+}
+
+TEST(Result, catch_all_returns_value) {
+  auto fn = []() -> result<uint8_t> {
+    return result_catch_all([]() -> uint8_t { return 129; });
+  };
+  ASSERT_EQ(129, fn().value_or_throw());
+}
+
 } // namespace folly
 
 #endif // FOLLY_HAS_RESULT