Work around for KT-63278 by renaming asHandler to asHandler1

Author: qwwdfsad

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

@@ -75,7 +75,7 @@ private class AwaitAll<T>(private val deferreds: Array<out Deferred<T>>) {
             val deferred = deferreds[i]
             deferred.start() // To properly await lazily started deferreds
             AwaitAllNode(cont).apply {
-                handle = deferred.invokeOnCompletion(asHandler)
+                handle = deferred.invokeOnCompletion(asHandler1)
             }
         }
         val disposer = DisposeHandlersOnCancel(nodes)

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

@@ -347,7 +347,7 @@ internal open class CancellableContinuationImpl<in T>(
         // Install the handle
         val handle = parent.invokeOnCompletion(
             onCancelling = true,
-            handler = ChildContinuation(this).asHandler
+            handler = ChildContinuation(this).asHandler1
         )
         _parentHandle.compareAndSet(null, handle)
         return handle

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

@@ -31,7 +31,7 @@ internal expect abstract class CompletionHandlerBase() : LockFreeLinkedListNode
     abstract fun invoke(cause: Throwable?)
 }
 
-internal expect val CompletionHandlerBase.asHandler: CompletionHandler
+internal expect val CompletionHandlerBase.asHandler1: CompletionHandler
 
 // More compact version of CompletionHandlerBase for CancellableContinuation with same workaround for JS
 internal expect abstract class CancelHandlerBase() {

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

@@ -491,7 +491,7 @@ public interface ChildHandle : DisposableHandle {
  * ```
  */
 internal fun Job.disposeOnCompletion(handle: DisposableHandle): DisposableHandle =
-    invokeOnCompletion(handler = DisposeOnCompletion(handle).asHandler)
+    invokeOnCompletion(handler = DisposeOnCompletion(handle).asHandler1)
 
 /**
  * Cancels the job and suspends the invoking coroutine until the cancelled job is complete.

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

@@ -558,7 +558,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
 
     private suspend fun joinSuspend() = suspendCancellableCoroutine<Unit> { cont ->
         // We have to invoke join() handler only on cancellation, on completion we will be resumed regularly without handlers
-        cont.disposeOnCancellation(invokeOnCompletion(handler = ResumeOnCompletion(cont).asHandler))
+        cont.disposeOnCancellation(invokeOnCompletion(handler = ResumeOnCompletion(cont).asHandler1))
     }
 
     @Suppress("UNCHECKED_CAST")
@@ -574,7 +574,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
             select.selectInRegistrationPhase(Unit)
             return
         }
-        val disposableHandle = invokeOnCompletion(SelectOnJoinCompletionHandler(select).asHandler)
+        val disposableHandle = invokeOnCompletion(SelectOnJoinCompletionHandler(select).asHandler1)
         select.disposeOnCompletion(disposableHandle)
     }
 
@@ -921,7 +921,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
     private tailrec fun tryWaitForChild(state: Finishing, child: ChildHandleNode, proposedUpdate: Any?): Boolean {
         val handle = child.childJob.invokeOnCompletion(
             invokeImmediately = false,
-            handler = ChildCompletion(this, state, child, proposedUpdate).asHandler
+            handler = ChildCompletion(this, state, child, proposedUpdate).asHandler1
         )
         if (handle !== NonDisposableHandle) return true // child is not complete and we've started waiting for it
         val nextChild = child.nextChild() ?: return false
@@ -971,7 +971,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
          * If child is attached when the job is already being cancelled, such child will receive immediate notification on
          * cancellation, but parent *will* wait for that child before completion and will handle its exception.
          */
-        return invokeOnCompletion(onCancelling = true, handler = ChildHandleNode(child).asHandler) as ChildHandle
+        return invokeOnCompletion(onCancelling = true, handler = ChildHandleNode(child).asHandler1) as ChildHandle
     }
 
     /**
@@ -1234,7 +1234,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
         val cont = AwaitContinuation(uCont.intercepted(), this)
         // we are mimicking suspendCancellableCoroutine here and call initCancellability, too.
         cont.initCancellability()
-        cont.disposeOnCancellation(invokeOnCompletion(ResumeAwaitOnCompletion(cont).asHandler))
+        cont.disposeOnCancellation(invokeOnCompletion(ResumeAwaitOnCompletion(cont).asHandler1))
         cont.getResult()
     }
 
@@ -1256,7 +1256,7 @@ public open class JobSupport constructor(active: Boolean) : Job, ChildJob, Paren
             }
             if (startInternal(state) >= 0) break // break unless needs to retry
         }
-        val disposableHandle = invokeOnCompletion(SelectOnAwaitCompletionHandler(select).asHandler)
+        val disposableHandle = invokeOnCompletion(SelectOnAwaitCompletionHandler(select).asHandler1)
         select.disposeOnCompletion(disposableHandle)
     }
 

kotlinx-coroutines-core/common/test/flow/operators/CombineParametersTestBase.kt

@@ -181,13 +181,4 @@ class CombineParametersTest : TestBase() {
         val result = flow.combine(flow) { a, b -> a + b }.toList()
         assertEquals(List(1024) { it * 2 } , result)
     }
-
-    @Test
-    fun testArrayType() = runTest {
-        val arr = flowOf(1)
-        combine(listOf(arr, arr)) {
-            println(it[0])
-            it[0]
-        }.toList().also { println(it) }
-    }
 }

kotlinx-coroutines-core/concurrent/src/CompletionHandler.kt

@@ -10,7 +10,7 @@ internal actual abstract class CompletionHandlerBase actual constructor() : Lock
     actual abstract override fun invoke(cause: Throwable?)
 }
 
-internal actual inline val CompletionHandlerBase.asHandler: CompletionHandler get() = this
+internal actual inline val CompletionHandlerBase.asHandler1: CompletionHandler get() = this
 
 internal actual abstract class CancelHandlerBase actual constructor() : CompletionHandler {
     actual abstract override fun invoke(cause: Throwable?)

kotlinx-coroutines-core/js/src/CompletionHandler.kt

@@ -12,7 +12,7 @@ internal actual abstract class CompletionHandlerBase : LinkedListNode() {
 }
 
 @Suppress("UnsafeCastFromDynamic")
-internal actual inline val CompletionHandlerBase.asHandler: CompletionHandler get() = asDynamic()
+internal actual inline val CompletionHandlerBase.asHandler1: CompletionHandler get() = asDynamic()
 
 internal actual abstract class CancelHandlerBase {
     @JsName("invoke")