Remove MODE_DIRECT resume mode

Now, there are only three resume modes that are used by DispatchedTask
and the corresponding constants are moved to DispatchedTask.kt file.

Author: elizarov

kotlinx-coroutines-core/common/src/Builders.common.kt

@@ -142,20 +142,20 @@ public suspend fun <T> withContext(
     newContext.checkCompletion()
     // FAST PATH #1 -- new context is the same as the old one
     if (newContext === oldContext) {
-        val coroutine = ScopeCoroutine(newContext, uCont) // MODE_DIRECT
+        val coroutine = ScopeCoroutine(newContext, uCont)
         return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
     }
     // FAST PATH #2 -- the new dispatcher is the same as the old one (something else changed)
     // `equals` is used by design (see equals implementation is wrapper context like ExecutorCoroutineDispatcher)
     if (newContext[ContinuationInterceptor] == oldContext[ContinuationInterceptor]) {
-        val coroutine = UndispatchedCoroutine(newContext, uCont) // MODE_UNDISPATCHED
+        val coroutine = UndispatchedCoroutine(newContext, uCont)
         // There are changes in the context, so this thread needs to be updated
         withCoroutineContext(newContext, null) {
             return@sc coroutine.startUndispatchedOrReturn(coroutine, block)
         }
     }
     // SLOW PATH -- use new dispatcher
-    val coroutine = DispatchedCoroutine(newContext, uCont) // MODE_CANCELLABLE
+    val coroutine = DispatchedCoroutine(newContext, uCont)
     coroutine.initParentJob()
     block.startCoroutineCancellable(coroutine, coroutine)
     coroutine.getResult()

kotlinx-coroutines-core/common/src/ResumeMode.kt

@@ -8,6 +8,13 @@ import kotlinx.coroutines.internal.*
 import kotlin.coroutines.*
 import kotlin.jvm.*
 
+@PublishedApi internal const val MODE_ATOMIC_DEFAULT = 0 // schedule non-cancellable dispatch for suspendCoroutine
+@PublishedApi internal const val MODE_CANCELLABLE = 1    // schedule cancellable dispatch for suspendCancellableCoroutine
+@PublishedApi internal const val MODE_UNDISPATCHED = 2   // when the thread is right, but need to mark it with current coroutine
+
+internal val Int.isCancellableMode get() = this == MODE_CANCELLABLE
+internal val Int.isDispatchedMode get() = this == MODE_ATOMIC_DEFAULT || this == MODE_CANCELLABLE
+
 internal abstract class DispatchedTask<in T>(
     @JvmField public var resumeMode: Int
 ) : SchedulerTask() {
@@ -89,7 +96,7 @@ internal abstract class DispatchedTask<in T>(
     }
 }
 
-internal fun <T> DispatchedTask<T>.dispatch(mode: Int = MODE_CANCELLABLE) {
+internal fun <T> DispatchedTask<T>.dispatch(mode: Int) {
     val delegate = this.delegate
     if (mode.isDispatchedMode && delegate is DispatchedContinuation<*> && mode.isCancellableMode == resumeMode.isCancellableMode) {
         // dispatch directly using this instance's Runnable implementation
@@ -125,7 +132,6 @@ internal fun <T> DispatchedTask<T>.resume(delegate: Continuation<T>, useMode: In
     when (useMode) {
         MODE_ATOMIC_DEFAULT -> delegate.resumeWith(result)
         MODE_CANCELLABLE -> delegate.resumeCancellableWith(result)
-        MODE_DIRECT -> ((delegate as? DispatchedContinuation)?.continuation ?: delegate).resumeWith(result)
         MODE_UNDISPATCHED -> (delegate as DispatchedContinuation).resumeUndispatchedWith(result)
         else -> error("Invalid mode $useMode")
     }

kotlinx-coroutines-core/common/src/internal/DispatchedTask.kt

@@ -128,7 +128,7 @@ public interface SelectInstance<in R> {
     /**
      * Returns completion continuation of this select instance.
      * This select instance must be _selected_ first.
-     * All resumption through this instance happen _directly_ without going through dispatcher ([MODE_DIRECT]).
+     * All resumption through this instance happen _directly_ without going through dispatcher.
      */
     public val completion: Continuation<R>
 
@@ -271,7 +271,7 @@ internal class SelectBuilderImpl<in R>(
         }
     }
 
-    // Resumes in MODE_DIRECT
+    // Resumes in direct mode, without going through dispatcher. Should be called in the same context.
     override fun resumeWith(result: Result<R>) {
         doResume({ result.toState() }) {
             if (result.isFailure) {
@@ -282,7 +282,7 @@ internal class SelectBuilderImpl<in R>(
         }
     }
 
-    // Resumes in MODE_CANCELLABLE
+    // Resumes in MODE_CANCELLABLE, can be called from an arbitrary context
     override fun resumeSelectCancellableWithException(exception: Throwable) {
         doResume({ CompletedExceptionally(exception) }) {
             uCont.intercepted().resumeCancellableWith(Result.failure(exception))