Consistent naming of handler base classes and their concrete impls

Author: elizarov

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/AbstractContinuation.kt

@@ -74,7 +74,7 @@ internal abstract class AbstractContinuation<in T>(
        name        state class          public state    description
        ------      ------------         ------------    -----------
        ACTIVE      Active               : Active        active, no listeners
-       SINGLE_A    CancellationHandler  : Active        active, one cancellation listener
+       SINGLE_A    CancelHandler        : Active        active, one cancellation listener
        CANCELLING  Cancelling           : Active        in the process of cancellation due to cancellation of parent job
        CANCELLED   Cancelled            : Cancelled     cancelled (final state)
        COMPLETED   any                  : Completed     produced some result or threw an exception (final state)
@@ -158,7 +158,7 @@ internal abstract class AbstractContinuation<in T>(
         resumeImpl(CompletedExceptionally(exception), resumeMode)
 
     public fun invokeOnCancellation(handler: CompletionHandler) {
-        var handleCache: CancellationHandler? = null
+        var handleCache: CancelHandler? = null
         loopOnState { state ->
             when (state) {
                 is Active -> {
@@ -167,7 +167,7 @@ internal abstract class AbstractContinuation<in T>(
                         return
                     }
                 }
-                is CancellationHandler -> error("It's prohibited to register multiple handlers, tried to register $handler, already has $state")
+                is CancelHandler -> error("It's prohibited to register multiple handlers, tried to register $handler, already has $state")
                 is CancelledContinuation -> {
                     /*
                      * Continuation is complete, invoke directly.
@@ -188,18 +188,12 @@ internal abstract class AbstractContinuation<in T>(
         }
     }
 
-    private fun makeHandler(handler: CompletionHandler): CancellationHandlerImpl<*> {
-        if (handler is CancellationHandlerImpl<*>) {
-            require(handler.continuation === this) { "Handler has non-matching continuation ${handler.continuation}, current: $this" }
-            return handler
-        }
-
-        return InvokeOnCancel(this, handler)
-    }
+    private fun makeHandler(handler: CompletionHandler): CancelHandler =
+        if (handler is CancelHandler) handler else InvokeOnCancel(handler)
 
     private fun tryCancel(state: NotCompleted, cause: Throwable?): Boolean {
         if (useCancellingState) {
-            require(state !is CancellationHandler) { "Invariant: 'Cancelling' state and cancellation handlers cannot be used together" }
+            require(state !is CancelHandler) { "Invariant: 'Cancelling' state and cancellation handlers cannot be used together" }
             return _state.compareAndSet(state, Cancelling(CancelledContinuation(this, cause)))
         }
 
@@ -342,7 +336,7 @@ internal abstract class AbstractContinuation<in T>(
         onCompletionInternal(mode)
 
         // Invoke cancellation handlers only if necessary
-        if (update is CancelledContinuation && expect is CancellationHandler) {
+        if (update is CancelledContinuation && expect is CancelHandler) {
             try {
                 expect.invoke(exceptionally?.cause)
             } catch (ex: Throwable) {
@@ -382,18 +376,14 @@ private val ACTIVE: Active = Active()
 // In progress of cancellation
 internal class Cancelling(@JvmField val cancel: CancelledContinuation) : NotCompleted
 
-internal abstract class CancellationHandlerImpl<out C : AbstractContinuation<*>>(@JvmField val continuation: C) :
-    CancellationHandler(), NotCompleted
+internal abstract class CancelHandler : CancelHandlerBase(), NotCompleted
 
-// Wrapper for lambdas, for the performance sake CancellationHandler can be subclassed directly
+// Wrapper for lambdas, for the performance sake CancelHandler can be subclassed directly
 private class InvokeOnCancel( // Clashes with InvokeOnCancellation
-    continuation: AbstractContinuation<*>,
     private val handler: CompletionHandler
-) : CancellationHandlerImpl<AbstractContinuation<*>>(continuation) {
-
+) : CancelHandler() {
     override fun invoke(cause: Throwable?) {
         handler.invoke(cause)
     }
-
     override fun toString() = "InvokeOnCancel[${handler.classSimpleName}@$hexAddress]"
 }

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CancellableContinuation.kt

@@ -219,16 +219,8 @@ public fun CancellableContinuation<*>.removeOnCancel(node: LockFreeLinkedListNod
  * Removes a given node on cancellation.
  * @suppress **This is unstable API and it is subject to change.**
  */
-public fun CancellableContinuation<*>.removeOnCancellation(node: LockFreeLinkedListNode): Unit {
-    val handler: CompletionHandler
-    if (this is CancellableContinuationImpl<*>) {
-        handler = RemoveOnCancel(this, node).asHandler
-    } else {
-        handler = { node.remove() }
-    }
-
-    invokeOnCancellation(handler)
-}
+public fun CancellableContinuation<*>.removeOnCancellation(node: LockFreeLinkedListNode) =
+    invokeOnCancellation(handler = RemoveOnCancel(node).asHandler)
 
 /**
  * Disposes a specified [handle] when this continuation is cancelled.
@@ -255,41 +247,19 @@ public fun CancellableContinuation<*>.disposeOnCompletion(handle: DisposableHand
  * invokeOnCancellation { handle.dispose() }
  * ```
  */
-public fun CancellableContinuation<*>.disposeOnCancellation(handle: DisposableHandle) {
-    val handler: CompletionHandler
-    if (this is CancellableContinuationImpl<*>) {
-        handler = DisposeOnCancellation(this, handle).asHandler
-    } else {
-        handler = { handle.dispose() }
-    }
-
-
-    invokeOnCancellation(handler)
-}
+public fun CancellableContinuation<*>.disposeOnCancellation(handle: DisposableHandle) =
+    invokeOnCancellation(handler = DisposeOnCancel(handle).asHandler)
 
 // --------------- implementation details ---------------
 
-// TODO: With separate class IDEA fails
-private class RemoveOnCancel(
-    cont: CancellableContinuationImpl<*>,
-    @JvmField val node: LockFreeLinkedListNode
-) : CancellationHandlerImpl<CancellableContinuationImpl<*>>(cont) {
-
-    override fun invoke(cause: Throwable?) {
-        node.remove()
-    }
-
+private class RemoveOnCancel(private val node: LockFreeLinkedListNode) : CancelHandler() {
+    override fun invoke(cause: Throwable?) { node.remove() }
     override fun toString() = "RemoveOnCancel[$node]"
 }
 
-private class DisposeOnCancellation(
-    continuation: CancellableContinuationImpl<*>,
-    private val handle: DisposableHandle
-) : CancellationHandlerImpl<CancellableContinuationImpl<*>>(continuation) {
-
+private class DisposeOnCancel(private val handle: DisposableHandle) : CancelHandler() {
     override fun invoke(cause: Throwable?) = handle.dispose()
-
-    override fun toString(): String = "DisposeOnCancellation[$handle]"
+    override fun toString(): String = "DisposeOnCancel[$handle]"
 }
 
 @PublishedApi

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/CompletionHandler.common.kt

@@ -39,17 +39,19 @@ public typealias CompletionHandler = (cause: Throwable?) -> Unit
 
 // We want class that extends LockFreeLinkedListNode & CompletionHandler but we cannot do it on Kotlin/JS,
 // so this expect class provides us with the corresponding abstraction in a platform-agnostic way.
-internal expect abstract class CompletionHandlerNode() : LockFreeLinkedListNode {
-    val asHandler: CompletionHandler
+internal expect abstract class CompletionHandlerBase() : LockFreeLinkedListNode {
     abstract fun invoke(cause: Throwable?)
 }
 
-// More compact version of CompletionHandlerNode for CancellableContinuation with same workaround for JS
-internal expect abstract class CancellationHandler() {
-    val asHandler: CompletionHandler
+internal expect val CompletionHandlerBase.asHandler: CompletionHandler
+
+// More compact version of CompletionHandlerBase for CancellableContinuation with same workaround for JS
+internal expect abstract class CancelHandlerBase() {
     abstract fun invoke(cause: Throwable?)
 }
 
+internal expect val CancelHandlerBase.asHandler: CompletionHandler
+
 // :KLUDGE: We have to invoke a handler in platform-specific way via `invokeIt` extension,
 // because we play type tricks on Kotlin/JS and handler is not necessarily a function there
 internal expect fun CompletionHandler.invokeIt(cause: Throwable?)

common/kotlinx-coroutines-core-common/src/main/kotlin/kotlinx/coroutines/experimental/JobSupport.kt

@@ -853,7 +853,7 @@ internal interface Incomplete {
 
 internal abstract class JobNode<out J : Job>(
     @JvmField val job: J
-) : CompletionHandlerNode(), DisposableHandle, Incomplete {
+) : CompletionHandlerBase(), DisposableHandle, Incomplete {
     override val isActive: Boolean get() = true
     override val list: NodeList? get() = null
     override fun dispose() = (job as JobSupport).removeNode(this)

core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CompletionHandler.kt

@@ -18,15 +18,17 @@ package kotlinx.coroutines.experimental
 
 import kotlinx.coroutines.experimental.internal.*
 
-internal actual abstract class CompletionHandlerNode actual constructor() : LockFreeLinkedListNode(), CompletionHandler {
-    actual inline val asHandler: CompletionHandler get() = this
+internal actual abstract class CompletionHandlerBase actual constructor() : LockFreeLinkedListNode(), CompletionHandler {
     actual abstract override fun invoke(cause: Throwable?)
 }
 
-internal actual abstract class CancellationHandler actual constructor() : CompletionHandler {
-    actual inline val asHandler: CompletionHandler get() = this
+internal actual inline val CompletionHandlerBase.asHandler: CompletionHandler get() = this
+
+internal actual abstract class CancelHandlerBase actual constructor() : CompletionHandler {
     actual abstract override fun invoke(cause: Throwable?)
 }
 
+internal actual inline val CancelHandlerBase.asHandler: CompletionHandler get() = this
+
 @Suppress("NOTHING_TO_INLINE")
 internal actual inline fun CompletionHandler.invokeIt(cause: Throwable?) = invoke(cause)

core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Future.kt

@@ -54,36 +54,26 @@ public fun CancellableContinuation<*>.cancelFutureOnCompletion(future: Future<*>
  * invokeOnCancellation { future.cancel(false) }
  * ```
  */
-public fun CancellableContinuation<*>.cancelFutureOnCancellation(future: Future<*>) {
-    if (this is AbstractContinuation<*>) {
-        invokeOnCancellation(handler = CancelFutureOnCancellation(this, future))
-    } else {
-        // Fallback if someone else implement CancellableContinuation
-        invokeOnCancellation { future.cancel(false)  }
-    }
-}
+public fun CancellableContinuation<*>.cancelFutureOnCancellation(future: Future<*>) =
+    invokeOnCancellation(handler = CancelFutureOnCancel(future))
 
 private class CancelFutureOnCompletion(
     job: Job,
     private val future: Future<*>
 ) : JobNode<Job>(job)  {
-    override fun invoke(reason: Throwable?) {
+    override fun invoke(cause: Throwable?) {
         // Don't interrupt when cancelling future on completion, because no one is going to reset this
         // interruption flag and it will cause spurious failures elsewhere
         future.cancel(false)
     }
     override fun toString() = "CancelFutureOnCompletion[$future]"
 }
 
-private class CancelFutureOnCancellation(
-    continuation: AbstractContinuation<*>,
-    private val future: Future<*>
-) : CancellationHandlerImpl<AbstractContinuation<*>>(continuation)  {
-
-    override fun invoke(reason: Throwable?) {
+private class CancelFutureOnCancel(private val future: Future<*>) : CancelHandler()  {
+    override fun invoke(cause: Throwable?) {
         // Don't interrupt when cancelling future on completion, because no one is going to reset this
         // interruption flag and it will cause spurious failures elsewhere
         future.cancel(false)
     }
-    override fun toString() = "CancelFutureOnCancellation[$future]"
+    override fun toString() = "CancelFutureOnCancel[$future]"
 }

js/kotlinx-coroutines-core-js/src/main/kotlin/kotlinx/coroutines/experimental/CompletionHandler.kt

@@ -18,21 +18,25 @@ package kotlinx.coroutines.experimental
 
 import kotlinx.coroutines.experimental.internal.*
 
-internal actual abstract class CompletionHandlerNode : LinkedListNode() {
-    @Suppress("UnsafeCastFromDynamic")
-    actual inline val asHandler: CompletionHandler get() = asDynamic()
+internal actual abstract class CompletionHandlerBase : LinkedListNode() {
+    @JsName("invoke")
     actual abstract fun invoke(cause: Throwable?)
 }
 
-internal actual abstract class CancellationHandler {
-    @Suppress("UnsafeCastFromDynamic")
-    actual inline val asHandler: CompletionHandler get() = asDynamic()
+@Suppress("UnsafeCastFromDynamic")
+internal actual inline val CompletionHandlerBase.asHandler: CompletionHandler get() = asDynamic()
+
+internal actual abstract class CancelHandlerBase {
+    @JsName("invoke")
     actual abstract fun invoke(cause: Throwable?)
 }
 
+@Suppress("UnsafeCastFromDynamic")
+internal actual inline val CancelHandlerBase.asHandler: CompletionHandler get() = asDynamic()
+
 internal actual fun CompletionHandler.invokeIt(cause: Throwable?) {
     when(jsTypeOf(this)) {
         "function" -> invoke(cause)
-        else -> (this as CompletionHandlerNode).invoke(cause)
+        else -> asDynamic().invoke(cause)
     }
 }