Simplify ExtendedCoroutinePromise interface

Summary:
- I see no benefit to `getHandle()` being part of the virtual inteface. The code certainly gets shorter!
- Remove `ExtendedCoroutineHandle::getPromise` -- it's is unused, and of dubious value
- Mark `getErrorHandle` as `final` throughout, the goal being that removing `final` from `TaskPromise` should not impact compiler optimizations since those classes would remain non-polymorphic.

Reviewed By: iahs

Differential Revision: D61404120

fbshipit-source-id: a337a57eb4aa1bdf34e98af527a28331cc0414f9

folly/coro/AsyncGenerator.h

@@ -486,10 +486,8 @@ struct BaseAsyncGeneratorPromise<true> {
 };
 
 template <typename Reference, typename Value, bool RequiresCleanup = false>
-class AsyncGeneratorPromise final
-    : public ExtendedCoroutinePromiseImpl<
-          AsyncGeneratorPromise<Reference, Value, RequiresCleanup>>,
-      BaseAsyncGeneratorPromise<RequiresCleanup> {
+class AsyncGeneratorPromise final : public ExtendedCoroutinePromise,
+                                    BaseAsyncGeneratorPromise<RequiresCleanup> {
   class YieldAwaiter {
    public:
     bool await_ready() noexcept { return false; }
@@ -720,7 +718,7 @@ class AsyncGeneratorPromise final
   folly::AsyncStackFrame& getAsyncFrame() noexcept { return asyncFrame_; }
 
   std::pair<ExtendedCoroutineHandle, AsyncStackFrame*> getErrorHandle(
-      exception_wrapper& ex) override {
+      exception_wrapper& ex) final {
     if (bypassExceptionThrowing_ == BypassExceptionThrowing::ACTIVE) {
       auto yieldAwaiter = yield_value(co_error(std::move(ex)));
       DCHECK(!yieldAwaiter.await_ready());

folly/coro/Coroutine.h

@@ -300,7 +300,6 @@ class ExtendedCoroutineHandle;
 // Extended promise interface folly::coro types are expected to implement
 class ExtendedCoroutinePromise {
  public:
-  virtual coroutine_handle<> getHandle() = 0;
   // Types may provide a more efficient resumption path when they know they will
   // be receiving an error result from the awaitee.
   // If they do, they might also update the active stack frame.
@@ -323,8 +322,13 @@ class ExtendedCoroutineHandle {
   /*implicit*/ ExtendedCoroutineHandle(coroutine_handle<> handle) noexcept
       : basic_(handle) {}
 
-  /*implicit*/ ExtendedCoroutineHandle(ExtendedCoroutinePromise* ptr) noexcept
-      : basic_(ptr->getHandle()), extended_(ptr) {}
+  template <
+      typename Promise,
+      std::enable_if_t<
+          std::is_base_of_v<ExtendedCoroutinePromise, Promise>,
+          int> = 0>
+  /*implicit*/ ExtendedCoroutineHandle(Promise* p) noexcept
+      : basic_(coroutine_handle<Promise>::from_promise(*p)), extended_(p) {}
 
   ExtendedCoroutineHandle() noexcept = default;
 
@@ -334,8 +338,6 @@ class ExtendedCoroutineHandle {
 
   coroutine_handle<> getHandle() const noexcept { return basic_; }
 
-  ExtendedCoroutinePromise* getPromise() const noexcept { return extended_; }
-
   std::pair<ExtendedCoroutineHandle, AsyncStackFrame*> getErrorHandle(
       exception_wrapper& ex) {
     if (extended_) {
@@ -360,23 +362,6 @@ class ExtendedCoroutineHandle {
   ExtendedCoroutinePromise* extended_{nullptr};
 };
 
-template <typename Promise>
-class ExtendedCoroutinePromiseImpl : public ExtendedCoroutinePromise {
- public:
-  coroutine_handle<> getHandle() final {
-    return coroutine_handle<Promise>::from_promise(
-        *static_cast<Promise*>(this));
-  }
-
-  std::pair<ExtendedCoroutineHandle, AsyncStackFrame*> getErrorHandle(
-      exception_wrapper&) override {
-    return {getHandle(), nullptr};
-  }
-
- protected:
-  ~ExtendedCoroutinePromiseImpl() = default;
-};
-
 } // namespace folly::coro
 
 #endif

folly/coro/Task.h

@@ -199,7 +199,7 @@ class TaskPromiseBase {
 // Separate from `TaskPromiseBase` so the compiler has less to specialize.
 template <typename Promise, typename T>
 class TaskPromiseCrtpBase : public TaskPromiseBase,
-                            public ExtendedCoroutinePromiseImpl<Promise> {
+                            public ExtendedCoroutinePromise {
  public:
   using StorageType = detail::lift_lvalue_reference_t<T>;
 
@@ -232,7 +232,7 @@ class TaskPromiseCrtpBase : public TaskPromiseBase,
   ~TaskPromiseCrtpBase() = default;
 
   std::pair<ExtendedCoroutineHandle, AsyncStackFrame*> getErrorHandle(
-      exception_wrapper& ex) override {
+      exception_wrapper& ex) final {
     auto& me = *static_cast<Promise*>(this);
     if (bypassExceptionThrowing_ == BypassExceptionThrowing::ACTIVE) {
       auto finalAwaiter = yield_value(co_error(std::move(ex)));

folly/coro/ViaIfAsync.h

@@ -112,7 +112,7 @@ template <bool IsStackAware>
 class ViaCoroutine {
  public:
   class promise_type final : public ViaCoroutinePromiseBase,
-                             public ExtendedCoroutinePromiseImpl<promise_type> {
+                             public ExtendedCoroutinePromise {
     struct FinalAwaiter {
       bool await_ready() noexcept { return false; }
 
@@ -154,13 +154,13 @@ class ViaCoroutine {
     folly::AsyncStackFrame& getLeafFrame() noexcept { return leafFrame_; }
 
     std::pair<ExtendedCoroutineHandle, AsyncStackFrame*> getErrorHandle(
-        exception_wrapper& ex) override {
+        exception_wrapper& ex) final {
       auto [handle, frame] = continuation_.getErrorHandle(ex);
       setContinuation(handle);
       if (frame && IsStackAware) {
         leafFrame_.setParentFrame(*frame);
       }
-      return {promise_type::getHandle(), nullptr};
+      return {coroutine_handle<promise_type>::from_promise(*this), nullptr};
     }
   };