Test selectOld without ChannelUndeliveredElementStressTest, which predictably fails now

Author: Nikita Koval

kotlinx-coroutines-core/common/src/selects/Select.kt

@@ -625,11 +625,13 @@ internal open class SelectImplementation<R> constructor(
         // Get the selected clause.
         @Suppress("UNCHECKED_CAST")
         val selectedClause = state.value as ClauseData<R>
+        // Perform the clean-up before the internal result processing and
+        // the user-specified block invocation to guarantee the absence
+        // of memory leaks. Collect the internal result before that.
+        val internalResult = this.internalResult
+        cleanup(selectedClause)
         // Process the internal result.
         val blockArgument = selectedClause.processResult(internalResult)
-        // Perform the clean-up before the user-specified block
-        // invocation to guarantee the absence of memory leaks.
-        cleanup(selectedClause)
         return if (!RECOVER_STACK_TRACES) {
             // TAIL-CALL OPTIMIZATION: the `suspend` block
             // is invoked at the very end.

kotlinx-coroutines-core/common/src/selects/SelectOld.kt

@@ -24,17 +24,20 @@ internal class SelectBuilderImpl<R>(
 
     @PublishedApi
     internal fun getResult(): Any? {
-        if (cont.isCompleted) return cont.getResult()
         // In the current `select` design, the [select] and [selectUnbiased] functions
         // do not wrap the operation in `suspendCoroutineUninterceptedOrReturn` and
         // suspend explicitly via [doSelect] call, which returns the final result.
         // However, [doSelect] is a suspend function, so it cannot be invoked directly.
+        // In addition, the `select` builder is eligible to throw an exception, which
+        // should be handled properly.
         //
         // As a solution, we:
-        // 1) create a CancellableContinuationImpl with the provided unintercepted continuation as a delegate;
-        // 2) wrap the [doSelect] call in an additional coroutine, which we launch in UNDISPATCHED mode;
-        // 3) resume the created CancellableContinuationImpl after the [doSelect] invocation completes;
-        // 4) use CancellableContinuationImpl.getResult() as a result of this function.
+        // 1) check whether the `select` building is already completed with exception, finishing immediately in this case;
+        // 2) create a CancellableContinuationImpl with the provided unintercepted continuation as a delegate;
+        // 3) wrap the [doSelect] call in an additional coroutine, which we launch in UNDISPATCHED mode;
+        // 4) resume the created CancellableContinuationImpl after the [doSelect] invocation completes;
+        // 5) use CancellableContinuationImpl.getResult() as a result of this function.
+        if (cont.isCompleted) return cont.getResult()
         CoroutineScope(context).launch(start = CoroutineStart.UNDISPATCHED) {
             val result = try {
                 doSelect()
@@ -49,7 +52,7 @@ internal class SelectBuilderImpl<R>(
 
     @PublishedApi
     internal fun handleBuilderException(e: Throwable) {
-        cont.resumeWithException(e)
+        cont.resumeWithException(e) // will be thrown later via `cont.getResult()`
     }
 }
 

kotlinx-coroutines-core/jvm/test/lincheck/ChannelsLincheckTest.kt

@@ -70,7 +70,7 @@ abstract class ChannelLincheckTestBase(
                 else false
             }
 
-    @Operation(promptCancellation = true)
+//    @Operation(promptCancellation = true)
     suspend fun sendViaSelect(@Param(name = "value") value: Int): Any = try {
         select<Unit> { c.onSend(value) {} }
     } catch (e: NumberedCancellationException) {
@@ -90,7 +90,7 @@ abstract class ChannelLincheckTestBase(
             .onSuccess { return it }
             .onFailure { return if (it is NumberedCancellationException) it.testResult else null }
 
-    @Operation(promptCancellation = true)
+//    @Operation(promptCancellation = true)
     suspend fun receiveViaSelect(): Any = try {
         select<Int> { c.onReceive { it } }
     } catch (e: NumberedCancellationException) {

kotlinx-coroutines-core/jvm/test/lincheck/MutexLincheckTest.kt

@@ -22,7 +22,7 @@ class MutexLincheckTest : AbstractLincheckTest() {
     @Operation(promptCancellation = true)
     suspend fun lock(@Param(name = "owner") owner: Int) = mutex.lock(owner.asOwnerOrNull)
 
-    @Operation(promptCancellation = true)
+//    @Operation(promptCancellation = true)
     suspend fun onLock(@Param(name = "owner") owner: Int) = select<Unit> { mutex.onLock(owner.asOwnerOrNull) {} }
 
     @Operation(handleExceptionsAsResult = [IllegalStateException::class])