util-core: c.t.u.Responder is a dead type

Problem

We have a type called `Responder` that houses the methods
that are already defined on Future. This does nothing but bloat
the itable of `Promise`, which is the only implementation of the
sealed `Responder` trait.

Solution

Fold the method definitions into `Promise` and call it a day.

Differential Revision: https://phabricator.twitter.biz/D824830

Author: Bryce Anderson

CHANGELOG.rst

@@ -32,6 +32,11 @@ Runtime Behavior Changes
 
 * util: Bump version of Caffeine to 2.9.3. ``PHAB_ID=D815761``
 
+Breaking API Changes
+~~~~~~~~~~~~~~~~~~~~
+
+* util-core: The `c.t.util.Responder` trait has been removed. ``PHAB_ID=D824830``
+
 22.1.0
 ------
 

util-core/src/main/scala/com/twitter/util/Promise.scala

@@ -323,45 +323,6 @@ object Promise {
 
   private val AlwaysUnit: Any => Unit = _ => ()
 
-  sealed trait Responder[A] { this: Future[A] =>
-    protected final def continueAll(wq: WaitQueue[A]): Unit = {
-      var ks = wq
-      while (ks ne WaitQueue.Empty) {
-        continue(ks.first)
-        ks = ks.rest
-      }
-    }
-
-    protected def continue(k: K[A]): Unit
-
-    /**
-     * Note: exceptions in responds are monitored.  That is, if the
-     * computation `k` throws a raw (ie.  not encoded in a Future)
-     * exception, it is handled by the current monitor, see
-     * [[Monitor]] for details.
-     */
-    def respond(k: Try[A] => Unit): Future[A] = {
-      continue(new Monitored(Local.save(), k))
-      this
-    }
-
-    def transform[B](f: Try[A] => Future[B]): Future[B] = {
-      val promise = interrupts[B](this)
-
-      continue(new FutureTransformer(Local.save(), f, promise))
-
-      promise
-    }
-
-    protected def transformTry[B](f: Try[A] => Try[B]): Future[B] = {
-      val promise = interrupts[B](this)
-
-      continue(new TryTransformer(Local.save(), f, promise))
-
-      promise
-    }
-  }
-
   // PUBLIC API
 
   /**
@@ -465,9 +426,44 @@ object Promise {
  * space leak is incurred from `flatMap` in the tail position since
  * intermediate promises are merged into the root promise.
  */
-class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[A]] {
+class Promise[A] extends Future[A] with Updatable[Try[A]] {
   import Promise._
 
+  private final def continueAll(wq: WaitQueue[A]): Unit = {
+    var ks = wq
+    while (ks ne WaitQueue.Empty) {
+      continue(ks.first)
+      ks = ks.rest
+    }
+  }
+
+  /**
+   * Note: exceptions in responds are monitored.  That is, if the
+   * computation `k` throws a raw (ie.  not encoded in a Future)
+   * exception, it is handled by the current monitor, see
+   * [[Monitor]] for details.
+   */
+  final def respond(k: Try[A] => Unit): Future[A] = {
+    continue(new Monitored(Local.save(), k))
+    this
+  }
+
+  final def transform[B](f: Try[A] => Future[B]): Future[B] = {
+    val promise = interrupts[B](this)
+
+    continue(new FutureTransformer(Local.save(), f, promise))
+
+    promise
+  }
+
+  final protected def transformTry[B](f: Try[A] => Try[B]): Future[B] = {
+    val promise = interrupts[B](this)
+
+    continue(new TryTransformer(Local.save(), f, promise))
+
+    promise
+  }
+
   // Note: this will always be one of:
   // - WaitQueue (Waiting)
   // - Interrupted
@@ -776,7 +772,7 @@ class Promise[A] extends Future[A] with Promise.Responder[A] with Updatable[Try[
    *
    * @throws Promise.ImmutableResult if the Promise is already populated
    */
-  def update(result: Try[A]): Unit = {
+  final def update(result: Try[A]): Unit = {
     updateIfEmpty(result) || {
       val current = Await.result(liftToTry)
       throw ImmutableResult(s"Result set multiple times. Value='$current', New='$result'")