Code style fixes

Author: ndkoval

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

@@ -9,7 +9,7 @@ import kotlinx.coroutines.*
 
 // returns the first segment `s` with `s.id >= id` or `CLOSED`
 // if all the segments in this linked list have lower `id` and the list is closed for further segment additions.
-private inline fun <S: Segment<S>> S.findSegmentInternal(id: Long, createNewSegment: (id: Long, prev: S?) -> S): SegmentOrClosed<S> {
+private inline fun <S : Segment<S>> S.findSegmentInternal(id: Long, createNewSegment: (id: Long, prev: S?) -> S): SegmentOrClosed<S> {
     // Go through `next` references and add new segments if needed,
     // similarly to the `push` in the Michael-Scott queue algorithm.
     // The only difference is that `CAS failure` means that the
@@ -59,7 +59,7 @@ private inline fun <S : Segment<S>> AtomicRef<S>.moveForward(to: S): Boolean = l
  * returns the segment `s` with `s.id >= id` or `CLOSED` if all the segments in this linked list have lower `id`
  * and the list is closed.
  */
-internal inline fun <S: Segment<S>> AtomicRef<S>.findSegmentAndMoveForward(id: Long, startFrom: S, createNewSegment: (id: Long, prev: S?) -> S): SegmentOrClosed<S> {
+internal inline fun <S : Segment<S>> AtomicRef<S>.findSegmentAndMoveForward(id: Long, startFrom: S, createNewSegment: (id: Long, prev: S?) -> S): SegmentOrClosed<S> {
     while (true) {
         val s = startFrom.findSegmentInternal(id, createNewSegment)
         if (s.isClosed || moveForward(s.segment)) return s
@@ -87,14 +87,15 @@ internal fun <S : Segment<S>> S.close(): S {
  * Essentially, this is a node in the Michael-Scott queue algorithm, but with
  * maintaining [prev] pointer for efficient [remove] implementation.
  */
-internal abstract class Segment<S: Segment<S>>(val id: Long, prev: S?, pointers: Int) {
+internal abstract class Segment<S : Segment<S>>(val id: Long, prev: S?, pointers: Int) {
     // Pointer to the next segment, updates similarly to the Michael-Scott queue algorithm.
     private val _next = atomic<Any?>(null)
     val nextOrClosed: NextSegmentOrClosed<S> get() = NextSegmentOrClosed(_next.value)
     fun trySetNext(value: S): Boolean = _next.compareAndSet(null, value)
 
     // Pointer to the previous segment, updates in [remove] function.
     val prev = atomic(prev)
+
     /**
      * Cleans the pointer to the previous segment.
      */
@@ -119,6 +120,7 @@ internal abstract class Segment<S: Segment<S>>(val id: Long, prev: S?, pointers:
 
     // increments the number of pointers if this segment is not logically removed\
     inline fun tryIncPointers() = cleanedAndPointers.addConditionally(1 shl POINTERS_SHIFT) { it != maxSlots }
+
     // returns `true` if this segment is logically removed after the decrement
     inline fun decPointers() = cleanedAndPointers.addAndGet(-(1 shl POINTERS_SHIFT)) == maxSlots
 
@@ -188,19 +190,19 @@ internal abstract class Segment<S: Segment<S>>(val id: Long, prev: S?, pointers:
 }
 
 private inline fun AtomicInt.addConditionally(delta: Int, condition: (cur: Int) -> Boolean): Boolean {
-    while(true) {
+    while (true) {
         val cur = this.value
         if (!condition(cur)) return false
         if (this.compareAndSet(cur, cur + delta)) return true
     }
 }
 
-internal inline class SegmentOrClosed<S: Segment<S>>(private val value: Any?) {
+internal inline class SegmentOrClosed<S : Segment<S>>(private val value: Any?) {
     val isClosed: Boolean get() = value === CLOSED
     val segment: S get() = if (value === CLOSED) error("Does not contain segment") else value as S
 }
 
-internal inline class NextSegmentOrClosed<S: Segment<S>>(private val value: Any?) {
+internal inline class NextSegmentOrClosed<S : Segment<S>>(private val value: Any?) {
     val isClosed: Boolean get() = value === CLOSED
     val segment: S? get() = if (isClosed) null else value as S?
 }

kotlinx-coroutines-core/common/src/sync/Semaphore.kt

@@ -132,7 +132,7 @@ private class SemaphoreImpl(private val permits: Int, acquiredPermits: Int) : Se
         cur + 1
     }
 
-    private suspend fun addToQueueAndSuspend() = suspendAtomicCancellableCoroutineReusable<Unit> sc@ { cont ->
+    private suspend fun addToQueueAndSuspend() = suspendAtomicCancellableCoroutineReusable<Unit> sc@{ cont ->
         val curTail = this.tail.value
         val enqIdx = enqIdx.getAndIncrement()
         val segment = this.tail.findSegmentAndMoveForward(id = enqIdx / SEGMENT_SIZE, startFrom = curTail,
@@ -148,7 +148,7 @@ private class SemaphoreImpl(private val permits: Int, acquiredPermits: Int) : Se
 
     @Suppress("UNCHECKED_CAST")
     internal fun resumeNextFromQueue() {
-        try_again@while (true) {
+        try_again@ while (true) {
             val curHead = this.head.value
             val deqIdx = deqIdx.getAndIncrement()
             val id = deqIdx / SEGMENT_SIZE
@@ -190,7 +190,7 @@ private class CancelSemaphoreAcquisitionHandler(
 
 private fun createSegment(id: Long, prev: SemaphoreSegment?) = SemaphoreSegment(id, prev, 0)
 
-private class SemaphoreSegment(id: Long, prev: SemaphoreSegment?, pointers: Int): Segment<SemaphoreSegment>(id, prev, pointers) {
+private class SemaphoreSegment(id: Long, prev: SemaphoreSegment?, pointers: Int) : Segment<SemaphoreSegment>(id, prev, pointers) {
     val acquirers = atomicArrayOfNulls<Any?>(SEGMENT_SIZE)
     override val maxSlots: Int get() = SEGMENT_SIZE
 

kotlinx-coroutines-core/jvm/test/internal/SegmentQueueTest.kt

@@ -14,7 +14,7 @@ class SegmentQueueTest : TestBase() {
     @Test
     fun simpleTest() {
         val q = SegmentBasedQueue<Int>()
-        assertEquals( 1, q.numberOfSegments)
+        assertEquals(1, q.numberOfSegments)
         assertEquals(null, q.dequeue())
         q.enqueue(1)
         assertEquals(1, q.numberOfSegments)