Cleanup: remove the BuilderInference annotation (#4543)

The `BuilderInference` annotation has no effect since Kotlin 2.0
and can be safely removed.

Author: dkhalanskyjb

benchmarks/src/jmh/kotlin/benchmarks/flow/scrabble/FlowPlaysScrabbleOpt.kt

@@ -181,7 +181,7 @@ public fun <T, R> Flow<T>.flatMapConcatIterable(transformer: (T) -> Iterable<R>)
     }
 }
 
-public inline fun <T> flow(@BuilderInference crossinline block: suspend FlowCollector<T>.() -> Unit): Flow<T> {
+public inline fun <T> flow(crossinline block: suspend FlowCollector<T>.() -> Unit): Flow<T> {
     return object : Flow<T> {
         override suspend fun collect(collector: FlowCollector<T>) {
             collector.block()

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

@@ -39,7 +39,7 @@ public fun <E> CoroutineScope.broadcast(
     capacity: Int = 1,
     start: CoroutineStart = CoroutineStart.LAZY,
     onCompletion: CompletionHandler? = null,
-    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
+    block: suspend ProducerScope<E>.() -> Unit
 ): BroadcastChannel<E> {
     val newContext = newCoroutineContext(context)
     val channel = BroadcastChannel<E>(capacity)

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

@@ -239,7 +239,7 @@ public suspend fun ProducerScope<*>.awaitClose(block: () -> Unit = {}) {
 public fun <E> CoroutineScope.produce(
     context: CoroutineContext = EmptyCoroutineContext,
     capacity: Int = Channel.RENDEZVOUS,
-    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
+    block: suspend ProducerScope<E>.() -> Unit
 ): ReceiveChannel<E> =
     produce(context, capacity, BufferOverflow.SUSPEND, CoroutineStart.DEFAULT, onCompletion = null, block = block)
 
@@ -261,7 +261,7 @@ public fun <E> CoroutineScope.produce(
     capacity: Int = 0,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onCompletion: CompletionHandler? = null,
-    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
+    block: suspend ProducerScope<E>.() -> Unit
 ): ReceiveChannel<E> =
     produce(context, capacity, BufferOverflow.SUSPEND, start, onCompletion, block)
 
@@ -273,7 +273,7 @@ internal fun <E> CoroutineScope.produce(
     onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onCompletion: CompletionHandler? = null,
-    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
+    block: suspend ProducerScope<E>.() -> Unit
 ): ReceiveChannel<E> {
     val channel = Channel<E>(capacity, onBufferOverflow)
     val newContext = newCoroutineContext(context)

kotlinx-coroutines-core/common/src/flow/Builders.kt

@@ -49,7 +49,7 @@ import kotlinx.coroutines.flow.internal.unsafeFlow as flow
  *
  * If you want to switch the context of execution of a flow, use the [flowOn] operator.
  */
-public fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = SafeFlow(block)
+public fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> = SafeFlow(block)
 
 // Named anonymous object
 private class SafeFlow<T>(private val block: suspend FlowCollector<T>.() -> Unit) : AbstractFlow<T>() {
@@ -236,7 +236,7 @@ public fun LongRange.asFlow(): Flow<Long> = flow {
  * }
  * ```
  */
-public fun <T> channelFlow(@BuilderInference block: suspend ProducerScope<T>.() -> Unit): Flow<T> =
+public fun <T> channelFlow(block: suspend ProducerScope<T>.() -> Unit): Flow<T> =
     ChannelFlowBuilder(block)
 
 /**
@@ -300,7 +300,7 @@ public fun <T> channelFlow(@BuilderInference block: suspend ProducerScope<T>.()
  * > `awaitClose` block can be called at any time due to asynchronous nature of cancellation, even
  * > concurrently with the call of the callback.
  */
-public fun <T> callbackFlow(@BuilderInference block: suspend ProducerScope<T>.() -> Unit): Flow<T> = CallbackFlowBuilder(block)
+public fun <T> callbackFlow(block: suspend ProducerScope<T>.() -> Unit): Flow<T> = CallbackFlowBuilder(block)
 
 // ChannelFlow implementation that is the first in the chain of flow operations and introduces (builds) a flow
 private open class ChannelFlowBuilder<T>(

kotlinx-coroutines-core/common/src/flow/Migration.kt

@@ -269,7 +269,7 @@ public fun <T> Flow<T>.forEach(action: suspend (value: T) -> Unit): Unit = noImp
     message = "Flow has less verbose 'scan' shortcut",
     replaceWith = ReplaceWith("scan(initial, operation)")
 )
-public fun <T, R> Flow<T>.scanFold(initial: R, @BuilderInference operation: suspend (accumulator: R, value: T) -> R): Flow<R> =
+public fun <T, R> Flow<T>.scanFold(initial: R, operation: suspend (accumulator: R, value: T) -> R): Flow<R> =
     noImpl()
 
 /**

kotlinx-coroutines-core/common/src/flow/internal/FlowCoroutine.kt

@@ -23,7 +23,7 @@ import kotlinx.coroutines.flow.internal.unsafeFlow as flow
  * } // <- CE will be rethrown here
  * ```
  */
-internal suspend fun <R> flowScope(@BuilderInference block: suspend CoroutineScope.() -> R): R =
+internal suspend fun <R> flowScope(block: suspend CoroutineScope.() -> R): R =
     suspendCoroutineUninterceptedOrReturn { uCont ->
         val coroutine = FlowCoroutine(uCont.context, uCont)
         coroutine.startUndispatchedOrReturn(coroutine, block)
@@ -42,7 +42,7 @@ internal suspend fun <R> flowScope(@BuilderInference block: suspend CoroutineSco
  * with additional constraint on cancellation.
  * To cancel child without cancelling itself, `cancel(ChildCancelledException())` should be used.
  */
-internal fun <R> scopedFlow(@BuilderInference block: suspend CoroutineScope.(FlowCollector<R>) -> Unit): Flow<R> =
+internal fun <R> scopedFlow(block: suspend CoroutineScope.(FlowCollector<R>) -> Unit): Flow<R> =
     flow {
         flowScope { block(this@flow) }
     }

kotlinx-coroutines-core/common/src/flow/internal/SafeCollector.common.kt

@@ -101,7 +101,7 @@ internal tailrec fun Job?.transitiveCoroutineParent(collectJob: Job?): Job? {
  * Used in our own operators where we trust the context of invocations.
  */
 @PublishedApi
-internal inline fun <T> unsafeFlow(@BuilderInference crossinline block: suspend FlowCollector<T>.() -> Unit): Flow<T> {
+internal inline fun <T> unsafeFlow(crossinline block: suspend FlowCollector<T>.() -> Unit): Flow<T> {
     return object : Flow<T> {
         override suspend fun collect(collector: FlowCollector<T>) {
             collector.block()

kotlinx-coroutines-core/common/src/flow/operators/Emitters.kt

@@ -31,7 +31,7 @@ import kotlin.jvm.*
  * ```
  */
 public inline fun <T, R> Flow<T>.transform(
-    @BuilderInference crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit
+    crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit
 ): Flow<R> = flow { // Note: safe flow is used here, because collector is exposed to transform on each operation
     collect { value ->
         transform(value)
@@ -41,7 +41,7 @@ public inline fun <T, R> Flow<T>.transform(
 // For internal operator implementation
 @PublishedApi
 internal inline fun <T, R> Flow<T>.unsafeTransform(
-    @BuilderInference crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit
+    crossinline transform: suspend FlowCollector<R>.(value: T) -> Unit
 ): Flow<R> = unsafeFlow { // Note: unsafe flow is used here, because unsafeTransform is only for internal use
     collect { value ->
         transform(value)

kotlinx-coroutines-core/common/src/flow/operators/Limit.kt

@@ -110,7 +110,7 @@ public fun <T> Flow<T>.takeWhile(predicate: suspend (T) -> Boolean): Flow<T> = f
  * ```
  */
 public fun <T, R> Flow<T>.transformWhile(
-    @BuilderInference transform: suspend FlowCollector<R>.(value: T) -> Boolean
+    transform: suspend FlowCollector<R>.(value: T) -> Boolean
 ): Flow<R> =
     safeFlow { // Note: safe flow is used here, because collector is exposed to transform on each operation
         // This return is needed to work around a bug in JS BE: KT-39227

kotlinx-coroutines-core/common/src/flow/operators/Merge.kt

@@ -159,7 +159,7 @@ public fun <T> Flow<Flow<T>>.flattenMerge(concurrency: Int = DEFAULT_CONCURRENCY
  * and size of its output buffer can be changed by applying subsequent [buffer] operator.
  */
 @ExperimentalCoroutinesApi
-public fun <T, R> Flow<T>.transformLatest(@BuilderInference transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R> =
+public fun <T, R> Flow<T>.transformLatest(transform: suspend FlowCollector<R>.(value: T) -> Unit): Flow<R> =
     ChannelFlowTransformLatest(transform, this)
 
 /**
@@ -185,7 +185,7 @@ public fun <T, R> Flow<T>.transformLatest(@BuilderInference transform: suspend F
  * This operator is [buffered][buffer] by default and size of its output buffer can be changed by applying subsequent [buffer] operator.
  */
 @ExperimentalCoroutinesApi
-public inline fun <T, R> Flow<T>.flatMapLatest(@BuilderInference crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> =
+public inline fun <T, R> Flow<T>.flatMapLatest(crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> =
     transformLatest { emitAll(transform(it)) }
 
 /**
@@ -209,5 +209,5 @@ public inline fun <T, R> Flow<T>.flatMapLatest(@BuilderInference crossinline tra
  * This operator is [buffered][buffer] by default and size of its output buffer can be changed by applying subsequent [buffer] operator.
  */
 @ExperimentalCoroutinesApi
-public fun <T, R> Flow<T>.mapLatest(@BuilderInference transform: suspend (value: T) -> R): Flow<R> =
+public fun <T, R> Flow<T>.mapLatest(transform: suspend (value: T) -> R): Flow<R> =
     transformLatest { emit(transform(it)) }