Calling a function containing atomic operations from a different file results in the failure of Native incremental compilation.

Made BufferedChannel#sendImpl function private.

This is a WA for KT-65554

Author: mvicsokolova

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

@@ -241,7 +241,7 @@ internal open class BufferedChannel<E>(
     /**
      * Abstract send implementation.
      */
-    protected inline fun <R> sendImpl(
+    private inline fun <R> sendImpl(
         /* The element to be sent. */
         element: E,
         /* The waiter to be stored in case of suspension,
@@ -350,6 +350,43 @@ internal open class BufferedChannel<E>(
         }
     }
 
+    protected fun trySendDropLatest(element: E, isSendOp: Boolean): ChannelResult<Unit> {
+        // Try to send the element without suspension.
+        val result = trySend(element)
+        // Complete on success or if this channel is closed.
+        if (result.isSuccess || result.isClosed) return result
+        // This channel is full. Drop the sending element.
+        // Call the `onUndeliveredElement` lambda ONLY for 'send()' invocations,
+        // for 'trySend()' it is responsibility of the caller
+        if (isSendOp) {
+            onUndeliveredElement?.callUndeliveredElementCatchingException(element)?.let {
+                throw it
+            }
+        }
+        return success(Unit)
+    }
+
+    protected fun trySendDropOldest(element: E): ChannelResult<Unit> =
+        sendImpl( // <-- this is an inline function
+            element = element,
+            // Put the element into the logical buffer even
+            // if this channel is already full, the `onSuspend`
+            // callback below extract the first (oldest) element.
+            waiter = BUFFERED,
+            // Finish successfully when a rendezvous has happened
+            // or the element has been buffered.
+            onRendezvousOrBuffered = { return success(Unit) },
+            // In case the algorithm decided to suspend, the element
+            // was added to the buffer. However, as the buffer is now
+            // overflowed, the first (oldest) element has to be extracted.
+            onSuspend = { segm, i ->
+                dropFirstElementUntilTheSpecifiedCellIsInTheBuffer(segm.id * SEGMENT_SIZE + i)
+                return success(Unit)
+            },
+            // If the channel is closed, return the corresponding result.
+            onClosed = { return closed(sendException) }
+        )
+
     private inline fun sendImplOnNoWaiter(
         /* The working cell is specified by
         the segment and the index in it. */

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

@@ -56,43 +56,6 @@ internal open class ConflatedBufferedChannel<E>(
         if (onBufferOverflow === DROP_LATEST) trySendDropLatest(element, isSendOp)
         else trySendDropOldest(element)
 
-    private fun trySendDropLatest(element: E, isSendOp: Boolean): ChannelResult<Unit> {
-        // Try to send the element without suspension.
-        val result = super.trySend(element)
-        // Complete on success or if this channel is closed.
-        if (result.isSuccess || result.isClosed) return result
-        // This channel is full. Drop the sending element.
-        // Call the `onUndeliveredElement` lambda ONLY for 'send()' invocations,
-        // for 'trySend()' it is responsibility of the caller
-        if (isSendOp) {
-            onUndeliveredElement?.callUndeliveredElementCatchingException(element)?.let {
-                throw it
-            }
-        }
-        return success(Unit)
-    }
-
-    private fun trySendDropOldest(element: E): ChannelResult<Unit> =
-        sendImpl( // <-- this is an inline function
-            element = element,
-            // Put the element into the logical buffer even
-            // if this channel is already full, the `onSuspend`
-            // callback below extract the first (oldest) element.
-            waiter = BUFFERED,
-            // Finish successfully when a rendezvous has happened
-            // or the element has been buffered.
-            onRendezvousOrBuffered = { return success(Unit) },
-            // In case the algorithm decided to suspend, the element
-            // was added to the buffer. However, as the buffer is now
-            // overflowed, the first (oldest) element has to be extracted.
-            onSuspend = { segm, i ->
-                dropFirstElementUntilTheSpecifiedCellIsInTheBuffer(segm.id * SEGMENT_SIZE + i)
-                return success(Unit)
-            },
-            // If the channel is closed, return the corresponding result.
-            onClosed = { return closed(sendException) }
-        )
-
     @Suppress("UNCHECKED_CAST")
     override fun registerSelectForSend(select: SelectInstance<*>, element: Any?) {
         // The plain `send(..)` operation never suspends. Thus, either this