avoid rethrowing exceptions in AsyncScope

Reviewed By: snarkmaster

Differential Revision: D69706244

fbshipit-source-id: 93c60b59b4b1fa1680a85622ada8f9a2e1742d1f

Author: yfeldblum

folly/coro/AsyncScope.h

@@ -161,25 +161,36 @@ class AsyncScope {
             std::is_same_v<await_result_t<Awaitable>, folly::Unit>,
         "Result of the task would be discarded. Make sure task result is either void or folly::Unit.");
 
+    exception_wrapper exn;
     try {
-      co_await std::move(awaitable);
-    } catch (const OperationCancelled&) {
+      if constexpr (detail::is_awaitable_try<Awaitable>) {
+        auto ret = co_await co_awaitTry(std::move(awaitable));
+        if (ret.hasException()) {
+          exn = std::move(ret.exception());
+        }
+      } else {
+        co_await std::move(awaitable);
+      }
     } catch (...) {
+      // not-awaitable-try awaitables and not-noexcept-copy-constructible values
+      exn = exception_wrapper(std::current_exception());
+    }
+    if (exn && !exn.get_exception<OperationCancelled>()) {
       if (throwOnJoin) {
         LOG(ERROR)
             << (source.has_value() ? sourceLocationToString(source.value())
                                    : "")
             << "Unhandled exception thrown from task added to AsyncScope: "
-            << folly::exceptionStr(current_exception());
+            << exn;
         if (!exceptionRaised.exchange(true)) {
-          maybeException = folly::exception_wrapper(current_exception());
+          maybeException = std::move(exn);
         }
       } else {
         LOG(DFATAL)
             << (source.has_value() ? sourceLocationToString(source.value())
                                    : "")
             << "Unhandled exception thrown from task added to AsyncScope: "
-            << folly::exceptionStr(current_exception());
+            << exn;
       }
     }
   }
@@ -255,8 +266,8 @@ inline Task<void> AsyncScope::joinAsync() noexcept {
   joinStarted_.store(true, std::memory_order_relaxed);
   co_await barrier_.arriveAndWait();
   joined_ = true;
-  if (maybeException_.has_exception_ptr()) {
-    maybeException_.throw_exception();
+  if (maybeException_) {
+    co_yield co_error{std::move(maybeException_)};
   }
 }
 

folly/coro/ViaIfAsync.h

@@ -574,8 +574,20 @@ using semi_await_result_t = await_result_t<decltype(folly::coro::co_viaIfAsync(
 
 namespace detail {
 
+template <typename Awaiter>
+using detect_await_resume_try =
+    decltype(FOLLY_DECLVAL(Awaiter).await_resume_try());
+
+template <typename Awaiter>
+constexpr bool is_awaiter_try = is_detected_v<detect_await_resume_try, Awaiter>;
+
+template <typename Awaitable>
+constexpr bool is_awaitable_try = is_awaiter_try<awaiter_type_t<Awaitable>>;
+
 template <typename Awaitable>
 class TryAwaiter {
+  static_assert(is_awaitable_try<Awaitable&&>);
+
   using Awaiter = awaiter_type_t<Awaitable>;
 
  public: