Cleanup: get rid of workarounds, cleanup guide, suppress/fix compilation warnings

Author: qwwdfsad

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

@@ -393,8 +393,7 @@ internal open class JobSupport constructor(active: Boolean) : Job, ChildJob, Par
     public final override fun invokeOnCompletion(handler: CompletionHandler): DisposableHandle =
         invokeOnCompletion(onCancelling = false, invokeImmediately = true, handler = handler)
 
-    // todo: non-final as a workaround for KT-21968, should be final in the future
-    public override fun invokeOnCompletion(
+    public final override fun invokeOnCompletion(
         onCancelling: Boolean,
         invokeImmediately: Boolean,
         handler: CompletionHandler

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

@@ -50,17 +50,16 @@ public suspend fun <T> withTimeout(timeMillis: Long, block: suspend CoroutineSco
 public suspend fun <T> withTimeoutOrNull(timeMillis: Long, block: suspend CoroutineScope.() -> T): T? {
     if (timeMillis <= 0L) return null
 
-    // Workaround for K/N bug
-    val array = arrayOfNulls<TimeoutCoroutine<T?, T?>>(1)
+    var coroutine: TimeoutCoroutine<T?, T?>? = null
     try {
         return suspendCoroutineUninterceptedOrReturn { uCont ->
             val timeoutCoroutine = TimeoutCoroutine(timeMillis, uCont)
-            array[0] = timeoutCoroutine
+            coroutine = timeoutCoroutine
             setupTimeout<T?, T?>(timeoutCoroutine, block)
         }
     } catch (e: TimeoutCancellationException) {
         // Return null iff it's our exception, otherwise propagate it upstream (e.g. in case of nested withTimeouts)
-        if (e.coroutine === array[0]) {
+        if (e.coroutine === coroutine) {
             return null
         }
         throw e

common/kotlinx-coroutines-core-common/src/channels/AbstractChannel.kt

@@ -265,6 +265,7 @@ internal abstract class AbstractSendChannel<E> : SendChannel<E> {
         if (handler !== null && handler !== HANDLER_INVOKED
             && onCloseHandler.compareAndSet(handler, HANDLER_INVOKED)) {
             // CAS failed -> concurrent invokeOnClose() invoked handler
+            @Suppress("UNCHECKED_CAST")
             (handler as Handler)(cause)
         }
     }

common/kotlinx-coroutines-core-common/src/channels/ConflatedBroadcastChannel.kt

@@ -181,6 +181,7 @@ public class ConflatedBroadcastChannel<E>() : BroadcastChannel<E> {
         val handler = onCloseHandler.value
         if (handler !== null && handler !== HANDLER_INVOKED
             && onCloseHandler.compareAndSet(handler, HANDLER_INVOKED)) {
+            @Suppress("UNCHECKED_CAST")
             (handler as Handler)(cause)
         }
     }

common/kotlinx-coroutines-core-common/test/AsyncTest.kt

@@ -2,7 +2,7 @@
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED") // KT-21913
+@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED", "UNREACHABLE_CODE") // KT-21913
 
 package kotlinx.coroutines
 

common/kotlinx-coroutines-core-common/test/CoroutineExceptionHandlerTest.kt

@@ -31,7 +31,7 @@ class CoroutineExceptionHandlerTest : TestBase() {
     @Test
     fun testCompletableDeferred() = runTest {
         expect(1)
-        val handler = CoroutineExceptionHandler { _, ex ->
+        val handler = CoroutineExceptionHandler { _, _ ->
             expectUnreached()
         }
         val parent = CompletableDeferred<Unit>()

common/kotlinx-coroutines-core-common/test/CoroutineScopeTest.kt

@@ -2,6 +2,8 @@
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
+@file:Suppress("UNREACHABLE_CODE")
+
 package kotlinx.coroutines
 
 import kotlinx.coroutines.internal.*
@@ -146,7 +148,7 @@ class CoroutineScopeTest : TestBase() {
             expect(3)
             throw TestException1()
         }
-        val two = async<Int>(start = CoroutineStart.ATOMIC) {
+        val two = async(start = CoroutineStart.ATOMIC) {
             try {
                 expect(4)
                 delay(Long.MAX_VALUE) // Emulates very long computation

common/kotlinx-coroutines-core-common/test/WithTimeoutTest.kt

@@ -3,7 +3,7 @@
  * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED") // KT-21913
+@file:Suppress("NAMED_ARGUMENTS_NOT_ALLOWED", "UNREACHABLE_CODE") // KT-21913
 
 package kotlinx.coroutines
 

common/kotlinx-coroutines-core-common/test/channels/ConflatedBroadcastChannelTest.kt

@@ -36,7 +36,7 @@ class ConflatedBroadcastChannelTest : TestBase() {
     fun testBasicScenario() = runTest {
         expect(1)
         val broadcast = ConflatedBroadcastChannel<String>()
-        assertTrue(exceptionFromNotInline { broadcast.value } is IllegalStateException)
+        assertTrue(exceptionFrom { broadcast.value } is IllegalStateException)
         assertNull(broadcast.valueOrNull)
 
         launch(start = CoroutineStart.UNDISPATCHED) {
@@ -88,7 +88,7 @@ class ConflatedBroadcastChannelTest : TestBase() {
         yield() // to second receiver
         expect(18)
         broadcast.close()
-        assertTrue(exceptionFromNotInline { broadcast.value } is IllegalStateException)
+        assertTrue(exceptionFrom { broadcast.value } is IllegalStateException)
         assertNull(broadcast.valueOrNull)
         expect(19)
         yield() // to second receiver
@@ -117,22 +117,12 @@ class ConflatedBroadcastChannelTest : TestBase() {
         finish(7)
     }
 
-    inline fun exceptionFrom(block: () -> Unit): Throwable? {
-        try {
+    private inline fun exceptionFrom(block: () -> Unit): Throwable? {
+        return try {
             block()
-            return null
+            null
         } catch (e: Throwable) {
-            return e
-        }
-    }
-
-    // Workaround for KT-23921
-    fun exceptionFromNotInline(block: () -> Unit): Throwable? {
-        try {
-            block()
-            return null
-        } catch (e: Throwable) {
-            return e
+            e
         }
     }
 }

core/kotlinx-coroutines-core/src/internal/LockFreeMPSCQueue.kt

@@ -5,7 +5,6 @@
 package kotlinx.coroutines.internal
 
 import kotlinx.atomicfu.*
-import kotlinx.coroutines.*
 import java.util.concurrent.atomic.*
 
 private typealias Core<E> = LockFreeMPSCQueueCore<E>
@@ -59,13 +58,12 @@ internal class LockFreeMPSCQueue<E : Any> {
  * *Note: This queue is NOT linearizable. It provides only quiescent consistency for its operations.*
  *
  * @see LockFreeMPSCQueue
- * @suppress **This is unstable API and it is subject to change.**
  */
 internal class LockFreeMPSCQueueCore<E : Any>(private val capacity: Int) {
     private val mask = capacity - 1
     private val _next = atomic<Core<E>?>(null)
     private val _state = atomic(0L)
-    private val array = AtomicReferenceArray<Any?>(capacity);
+    private val array = AtomicReferenceArray<Any?>(capacity)
 
     init {
         check(mask <= MAX_CAPACITY_MASK)
@@ -148,6 +146,7 @@ internal class LockFreeMPSCQueueCore<E : Any>(private val capacity: Int) {
                 // Slow-path for remove in case of interference
                 var cur = this
                 while (true) {
+                    @Suppress("UNUSED_VALUE")
                     cur = cur.removeSlowPath(head, newHead) ?: return element
                 }
             }