Update convention

Author: dzharkov

kotlinx-coroutines-async/src/main/kotlin/async.kt

@@ -10,8 +10,9 @@ import java.util.concurrent.CompletableFuture
 import java.util.concurrent.TimeUnit
 import javax.swing.SwingUtilities
 import kotlin.coroutines.Continuation
-import kotlin.coroutines.ResumeInterceptor
+import kotlin.coroutines.ContinuationDispatcher
 import kotlin.coroutines.startCoroutine
+import kotlin.coroutines.suspendCoroutine
 
 /**
  * Run asynchronous computations based on [c] coroutine parameter
@@ -49,16 +50,16 @@ fun <T> async(
             },
 
             if (continuationWrapper != null) {
-                object: ResumeInterceptor {
-                    override fun <P> interceptResume(data: P, continuation: Continuation<P>): Boolean {
+                object: ContinuationDispatcher {
+                    override fun <P> dispatchResume(data: P, continuation: Continuation<P>): Boolean {
                         continuationWrapper {
                             continuation.resume(data)
                         }
 
                         return true
                     }
 
-                    override fun interceptResumeWithException(exception: Throwable, continuation: Continuation<*>): Boolean {
+                    override fun dispatchResumeWithException(exception: Throwable, continuation: Continuation<*>): Boolean {
                         continuationWrapper {
                             continuation.resumeWithException(exception)
                         }
@@ -93,7 +94,7 @@ fun asyncUI(
 typealias ContinuationWrapper = (() -> Unit) -> Unit
 
 suspend fun <V> CompletableFuture<V>.await(): V =
-        runWithCurrentContinuation {
+        suspendCoroutine {
             whenComplete { value, throwable ->
                 if (throwable == null)
                     it.resume(value)
@@ -107,41 +108,41 @@ suspend fun <V> CompletableFuture<V>.await(): V =
 suspend fun AsynchronousFileChannel.aRead(
         buf: ByteBuffer,
         position: Long
-) = runWithCurrentContinuation<Int> { c ->
+) = suspendCoroutine<Int> { c ->
     this.read(buf, position, null, AsyncIOHandler(c))
 }
 
 suspend fun AsynchronousFileChannel.aWrite(
         buf: ByteBuffer,
         position: Long
-) = runWithCurrentContinuation<Int> { c ->
+) = suspendCoroutine<Int> { c ->
     this.write(buf, position, null, AsyncIOHandler(c))
 }
 
 suspend fun AsynchronousServerSocketChannel.aAccept() =
-        runWithCurrentContinuation<AsynchronousSocketChannel> { c ->
+        suspendCoroutine<AsynchronousSocketChannel> { c ->
             this.accept(null, AsyncIOHandler(c))
         }
 
 suspend fun AsynchronousSocketChannel.aConnect(
         socketAddress: SocketAddress
-) = runWithCurrentContinuation<Unit> { c ->
+) = suspendCoroutine<Unit> { c ->
     this.connect(socketAddress, null, AsyncVoidIOHandler(c))
 }
 
 suspend fun AsynchronousSocketChannel.aRead(
         buf: ByteBuffer,
         timeout: Long = 0L,
         timeUnit: TimeUnit = TimeUnit.MILLISECONDS
-) = runWithCurrentContinuation<Int> { c ->
+) = suspendCoroutine<Int> { c ->
     this.read(buf, timeout, timeUnit, null, AsyncIOHandler(c))
 }
 
 suspend fun AsynchronousSocketChannel.aWrite(
         buf: ByteBuffer,
         timeout: Long = 0L,
         timeUnit: TimeUnit = TimeUnit.MILLISECONDS
-) = runWithCurrentContinuation<Int> { c ->
+) = suspendCoroutine<Int> { c ->
     this.write(buf, timeout, timeUnit, null, AsyncIOHandler(c))
 }
 

kotlinx-coroutines-generate/src/main/kotlin/generate.kt

@@ -1,9 +1,7 @@
 package kotlinx.coroutines
 
-import kotlin.coroutines.Continuation
-import kotlin.coroutines.SUSPENDED
-import kotlin.coroutines.createCoroutine
-import kotlin.coroutines.suspendWithCurrentContinuation
+import kotlin.coroutines.*
+import kotlin.coroutines.CoroutineIntrinsics.SUSPENDED
 
 /**
  * Creates a Sequence object based on received coroutine [c].
@@ -35,7 +33,7 @@ private class GeneratedIterator<T>(block: suspend Generator<T>.() -> Unit) : Abs
     override fun computeNext() {
         nextStep.resume(Unit)
     }
-    suspend override fun yield(value: T) = suspendWithCurrentContinuation<Unit> { c ->
+    suspend override fun yield(value: T) = CoroutineIntrinsics.suspendCoroutineOrReturn <Unit> { c ->
         setNext(value)
         nextStep = c
 

kotlinx-coroutines-rx/src/main/kotlin/asyncRx.kt

@@ -4,6 +4,7 @@ import rx.Observable
 import rx.subjects.AsyncSubject
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.startCoroutine
+import kotlin.coroutines.suspendCoroutine
 
 /**
  * Run asynchronous computations based on [c] coroutine parameter
@@ -45,12 +46,12 @@ suspend fun <V> Observable<V>.awaitLast(): V = last().awaitOne()
 
 suspend fun <V> Observable<V>.awaitSingle(): V = single().awaitOne()
 
-private suspend fun <V> Observable<V>.awaitOne(): V = runWithCurrentContinuation<V> { x ->
+private suspend fun <V> Observable<V>.awaitOne(): V = suspendCoroutine<V> { x ->
     subscribe(x::resume, x::resumeWithException)
 }
 
 suspend fun <V> Observable<V>.applyForEachAndAwait(
         block: (V) -> Unit
-) = runWithCurrentContinuation<Unit> { x->
+) = suspendCoroutine<Unit> { x->
     this.subscribe(block, x::resumeWithException, { x.resume(Unit) })
 }