change remove()

Author: de-shyt

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

@@ -2512,8 +2512,8 @@ internal open class BufferedChannel<E>(
     This method is used in the physical removal of the segment. It helps to move pointers forward from
     the segment which was physically removed.
      */
-    internal fun movePointersForwardFrom(from: ChannelSegment<E>) {
-        check(from.isRemoved) { "Trying to move channel pointers from the alive segment." }
+    internal fun movePointersForwardFromRemovedSegment(from: ChannelSegment<E>) {
+        if (!from.isRemoved) return
         if (from == sendSegment.value) sendSegment.moveToSpecifiedOrLast(from.id, from)
         if (from == receiveSegment.value) receiveSegment.moveToSpecifiedOrLast(from.id, from)
         if (from == bufferEndSegment.value) bufferEndSegment.moveToSpecifiedOrLast(from.id, from)
@@ -2785,13 +2785,13 @@ internal class ChannelSegment<E>(id: Long, prev: ChannelSegment<E>?, channel: Bu
     /**
      * Removes the segment physically from the segment list.
      *
-     * If the physical removal was successful and there are channel pointers pointing on this segment,
-     * the [BufferedChannel.movePointersForwardFrom] method is invoked to move them further on the segment list.
+     * After the physical removal is finished and there are channel pointers referencing the removed segment,
+     * the [BufferedChannel.movePointersForwardFromRemovedSegment] method is invoked to move them further on the segment list.
      */
-    override fun remove(): Boolean =
-        super.remove().also {
-            if (it) channel.movePointersForwardFrom(this)
-        }
+    override fun remove() {
+        super.remove()
+        channel.movePointersForwardFromRemovedSegment(this)
+    }
 
     // ########################
     // # Cancellation Support #

kotlinx-coroutines-core/common/src/internal/ConcurrentLinkedList.kt

@@ -200,11 +200,11 @@ internal abstract class ConcurrentLinkedListNode<N : ConcurrentLinkedListNode<N>
      *
      * Returns `true`, if the node was physically removed, and `false` otherwise.
      */
-    open fun remove(): Boolean {
+    open fun remove() {
         assert { isRemoved || isTail } // The node should be logically removed at first.
         // The physical tail cannot be removed. Instead, we remove it when
         // a new segment is added and this segment is not the tail one anymore.
-        if (isTail) return false
+        if (isTail) return
         while (true) {
             // Read `next` and `prev` pointers ignoring logically removed nodes.
             val prev = aliveSegmentLeft
@@ -216,7 +216,7 @@ internal abstract class ConcurrentLinkedListNode<N : ConcurrentLinkedListNode<N>
             if (next.isRemoved && !next.isTail) continue
             if (prev !== null && prev.isRemoved) continue
             // This node is removed.
-            return true
+            return
         }
     }