Make EventLoop internal, @JvmName("from") for ExecutorService.asCoroutineDispatcher

Author: qwwdfsad

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-core.txt

@@ -235,32 +235,15 @@ public abstract interface class kotlinx/coroutines/DisposableHandle {
 	public abstract fun dispose ()V
 }
 
-public abstract interface class kotlinx/coroutines/EventLoop : kotlin/coroutines/ContinuationInterceptor {
-	public abstract fun processNextEvent ()J
-}
-
-public final class kotlinx/coroutines/EventLoop$DefaultImpls {
-	public static fun fold (Lkotlinx/coroutines/EventLoop;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
-	public static fun get (Lkotlinx/coroutines/EventLoop;Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext$Element;
-	public static fun minusKey (Lkotlinx/coroutines/EventLoop;Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext;
-	public static fun plus (Lkotlinx/coroutines/EventLoop;Lkotlin/coroutines/CoroutineContext;)Lkotlin/coroutines/CoroutineContext;
-	public static fun releaseInterceptedContinuation (Lkotlinx/coroutines/EventLoop;Lkotlin/coroutines/Continuation;)V
-}
-
-public final class kotlinx/coroutines/EventLoopKt {
-	public static final fun EventLoop (Ljava/lang/Thread;Lkotlinx/coroutines/Job;)Lkotlinx/coroutines/EventLoop;
-	public static synthetic fun EventLoop$default (Ljava/lang/Thread;Lkotlinx/coroutines/Job;ILjava/lang/Object;)Lkotlinx/coroutines/EventLoop;
-}
-
 public abstract class kotlinx/coroutines/ExecutorCoroutineDispatcher : kotlinx/coroutines/CoroutineDispatcher, java/io/Closeable {
 	public fun <init> ()V
 	public abstract fun close ()V
 	public abstract fun getExecutor ()Ljava/util/concurrent/Executor;
 }
 
 public final class kotlinx/coroutines/ExecutorsKt {
-	public static final fun asCoroutineDispatcher (Ljava/util/concurrent/ExecutorService;)Lkotlinx/coroutines/ExecutorCoroutineDispatcher;
 	public static final fun from (Ljava/util/concurrent/Executor;)Lkotlinx/coroutines/CoroutineDispatcher;
+	public static final fun from (Ljava/util/concurrent/ExecutorService;)Lkotlinx/coroutines/ExecutorCoroutineDispatcher;
 }
 
 public abstract interface annotation class kotlinx/coroutines/ExperimentalCoroutinesApi : java/lang/annotation/Annotation {

core/kotlinx-coroutines-core/src/EventLoop.kt

@@ -6,7 +6,6 @@ package kotlinx.coroutines
 
 import kotlinx.atomicfu.*
 import kotlinx.coroutines.internal.*
-import java.util.concurrent.locks.*
 import kotlin.coroutines.*
 
 /**
@@ -18,8 +17,7 @@ import kotlin.coroutines.*
  *
  * @suppress **This an internal API and should not be used from general code.**
  */
-@InternalCoroutinesApi // todo: review KDoc references to this interface
-public interface EventLoop: ContinuationInterceptor {
+internal interface EventLoop: ContinuationInterceptor {
     /**
      * Processes next event in this event loop.
      *
@@ -31,28 +29,6 @@ public interface EventLoop: ContinuationInterceptor {
     public fun processNextEvent(): Long
 }
 
-/**
- * Creates a new event loop that is bound the specified [thread] (current thread by default) and
- * stops accepting new events when [parentJob] completes. Every continuation that is scheduled
- * onto this event loop unparks the specified thread via [LockSupport.unpark].
- *
- * The main event-processing loop using the resulting `eventLoop` object should look like this:
- * ```
- * while (needsToBeRunning) {
- *     if (Thread.interrupted()) break // or handle somehow
- *     LockSupport.parkNanos(eventLoop.processNextEvent()) // event loop will unpark
- * }
- * ```
- *
- * @suppress **This an internal API and should not be used from general code.**
- */
-@Suppress("FunctionName")
-@InternalCoroutinesApi
-public fun EventLoop(thread: Thread = Thread.currentThread(), parentJob: Job? = null): EventLoop =
-    EventLoopImpl(thread).apply {
-        if (parentJob != null) initParentJob(parentJob)
-    }
-
 private val DISPOSED_TASK = Symbol("REMOVED_TASK")
 
 // results for scheduleImpl
@@ -362,17 +338,6 @@ internal abstract class ThreadEventLoop(
     }
 }
 
-private class EventLoopImpl(thread: Thread) : ThreadEventLoop(thread) {
-    private var parentJob: Job? = null
-
-    override val isCompleted: Boolean get() = parentJob?.isCompleted == true
-
-    fun initParentJob(parentJob: Job) {
-        require(this.parentJob == null)
-        this.parentJob = parentJob
-    }
-}
-
 internal class BlockingEventLoop(thread: Thread) : ThreadEventLoop(thread) {
     @Volatile
     public override var isCompleted: Boolean = false

core/kotlinx-coroutines-core/src/Executors.kt

@@ -34,6 +34,7 @@ public abstract class ExecutorCoroutineDispatcher: CoroutineDispatcher(), Closea
 /**
  * Converts an instance of [ExecutorService] to an implementation of [ExecutorCoroutineDispatcher].
  */
+@JvmName("from") // this is for a nice Java API, see issue #255
 public fun ExecutorService.asCoroutineDispatcher(): ExecutorCoroutineDispatcher =
     // we know that an implementation of Executor.asCoroutineDispatcher actually returns a closeable one
     (this as Executor).asCoroutineDispatcher() as ExecutorCoroutineDispatcher

core/kotlinx-coroutines-core/src/test_/TestCoroutineContext.kt

@@ -193,7 +193,7 @@ class TestCoroutineContext(private val name: String? = null) : CoroutineContext
     private fun processNextEvent(): Long {
         val current = queue.peek()
         if (current != null) {
-            /** Automatically advance time for [EventLoop]-callbacks */
+            // Automatically advance time for EventLoop callbacks
             triggerActions(current.time)
         }
         return if (queue.isEmpty) Long.MAX_VALUE else 0L