Reduce hand-rolled ArrayQueue with ArrayDeque in standard library in order to (potentially) reduce dex size

Move ArrayQueue to JS-specific source-set to avoid touching JS

Author: qwwdfsad

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

@@ -36,7 +36,7 @@ internal abstract class EventLoop : CoroutineDispatcher() {
      * Queue used by [Dispatchers.Unconfined] tasks.
      * These tasks are thread-local for performance and take precedence over the rest of the queue.
      */
-    private var unconfinedQueue: ArrayQueue<DispatchedTask<*>>? = null
+    private var unconfinedQueue: ArrayDeque<DispatchedTask<*>>? = null
 
     /**
      * Processes next event in this event loop.
@@ -49,7 +49,7 @@ internal abstract class EventLoop : CoroutineDispatcher() {
      * **NOTE**: Must be invoked only from the event loop's thread
      *          (no check for performance reasons, may be added in the future).
      */
-    public open fun processNextEvent(): Long {
+    open fun processNextEvent(): Long {
         if (!processUnconfinedEvent()) return Long.MAX_VALUE
         return 0
     }
@@ -59,10 +59,10 @@ internal abstract class EventLoop : CoroutineDispatcher() {
     protected open val nextTime: Long
         get() {
             val queue = unconfinedQueue ?: return Long.MAX_VALUE
-            return if (queue.isEmpty) Long.MAX_VALUE else 0L
+            return if (queue.isEmpty()) Long.MAX_VALUE else 0L
         }
 
-    public fun processUnconfinedEvent(): Boolean {
+    fun processUnconfinedEvent(): Boolean {
         val queue = unconfinedQueue ?: return false
         val task = queue.removeFirstOrNull() ?: return false
         task.run()
@@ -74,27 +74,27 @@ internal abstract class EventLoop : CoroutineDispatcher() {
      * By default, event loop implementation is thread-local and should not processed in the context
      * (current thread's event loop should be processed instead).
      */
-    public open fun shouldBeProcessedFromContext(): Boolean = false
+    open fun shouldBeProcessedFromContext(): Boolean = false
 
     /**
      * Dispatches task whose dispatcher returned `false` from [CoroutineDispatcher.isDispatchNeeded]
      * into the current event loop.
      */
-    public fun dispatchUnconfined(task: DispatchedTask<*>) {
+    fun dispatchUnconfined(task: DispatchedTask<*>) {
         val queue = unconfinedQueue ?:
-            ArrayQueue<DispatchedTask<*>>().also { unconfinedQueue = it }
+            ArrayDeque<DispatchedTask<*>>().also { unconfinedQueue = it }
         queue.addLast(task)
     }
 
-    public val isActive: Boolean
+    val isActive: Boolean
         get() = useCount > 0
 
-    public val isUnconfinedLoopActive: Boolean
+    val isUnconfinedLoopActive: Boolean
         get() = useCount >= delta(unconfined = true)
 
     // May only be used from the event loop's thread
-    public val isUnconfinedQueueEmpty: Boolean
-        get() = unconfinedQueue?.isEmpty ?: true
+    val isUnconfinedQueueEmpty: Boolean
+        get() = unconfinedQueue?.isEmpty() ?: true
 
     private fun delta(unconfined: Boolean) =
         if (unconfined) (1L shl 32) else 1L
@@ -200,7 +200,7 @@ internal abstract class EventLoopImplBase: EventLoopImplPlatform(), Delay {
         }
     }
 
-    protected override val nextTime: Long
+    override val nextTime: Long
         get() {
             if (super.nextTime == 0L) return 0L
             val queue = _queue.value
@@ -227,7 +227,7 @@ internal abstract class EventLoopImplBase: EventLoopImplPlatform(), Delay {
         rescheduleAllDelayed()
     }
 
-    public override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
+    override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
         val timeNanos = delayToNanos(timeMillis)
         if (timeNanos < MAX_DELAY_NS) {
             val now = nanoTime()
@@ -283,7 +283,7 @@ internal abstract class EventLoopImplBase: EventLoopImplPlatform(), Delay {
         return nextTime
     }
 
-    public final override fun dispatch(context: CoroutineContext, block: Runnable) = enqueue(block)
+    final override fun dispatch(context: CoroutineContext, block: Runnable) = enqueue(block)
 
     open fun enqueue(task: Runnable) {
         if (enqueueImpl(task)) {
@@ -362,7 +362,7 @@ internal abstract class EventLoopImplBase: EventLoopImplPlatform(), Delay {
 
     }
 
-    public fun schedule(now: Long, delayedTask: DelayedTask) {
+    fun schedule(now: Long, delayedTask: DelayedTask) {
         when (scheduleImpl(now, delayedTask)) {
             SCHEDULE_OK -> if (shouldUnpark(delayedTask)) unpark()
             SCHEDULE_COMPLETED -> reschedule(now, delayedTask)
@@ -481,7 +481,6 @@ internal abstract class EventLoopImplBase: EventLoopImplPlatform(), Delay {
         final override fun dispose() {
             val heap = _heap
             if (heap === DISPOSED_TASK) return // already disposed
-            @Suppress("UNCHECKED_CAST")
             (heap as? DelayedTaskQueue)?.remove(this) // remove if it is in heap (first)
             _heap = DISPOSED_TASK // never add again to any heap
         }
@@ -530,7 +529,7 @@ internal expect fun createEventLoop(): EventLoop
 internal expect fun nanoTime(): Long
 
 internal expect object DefaultExecutor {
-    public fun enqueue(task: Runnable)
+    fun enqueue(task: Runnable)
 }
 
 /**

kotlinx-coroutines-core/common/src/internal/ArrayQueue.kt renamed to kotlinx-coroutines-core/js/src/internal/ArrayQueue.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2016-2022 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package kotlinx.coroutines.internal
@@ -11,22 +11,22 @@ internal open class ArrayQueue<T : Any> {
 
     val isEmpty: Boolean get() = head == tail
 
-    public fun addLast(element: T) {
+    fun addLast(element: T) {
         elements[tail] = element
         tail = (tail + 1) and elements.size - 1
         if (tail == head) ensureCapacity()
     }
 
     @Suppress("UNCHECKED_CAST")
-    public fun removeFirstOrNull(): T? {
+    fun removeFirstOrNull(): T? {
         if (head == tail) return null
         val element = elements[head]
         elements[head] = null
         head = (head + 1) and elements.size - 1
         return element as T
     }
 
-    public fun clear() {
+    fun clear() {
         head = 0
         tail = 0
         elements = arrayOfNulls(elements.size)