[FE] Remove BuilderInference annotation from tests

compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInference.kt

@@ -1,4 +1,4 @@
-fun <T> foo(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: MutableList<T>.() -> Unit): T = null!!
+fun <T> foo(@<!DEPRECATION, OPT_IN_USAGE_ERROR!>BuilderInference<!> block: MutableList<T>.() -> Unit): T = null!!
 
 fun takeString(s: String) {}
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/inference/builderInferenceFromStdlib.kt

@@ -12,7 +12,7 @@ fun test_2() {
     takeList(list)
 }
 
-fun <E> myBuildList(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> builderAction: MutableList<E>.() -> Unit): List<E> {
+fun <E> myBuildList(@<!DEPRECATION, OPT_IN_USAGE_ERROR!>BuilderInference<!> builderAction: MutableList<E>.() -> Unit): List<E> {
     return ArrayList<E>().apply(builderAction)
 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/problems/KtFirCompositeScope.kt

@@ -2,7 +2,7 @@ interface KtScope {
     fun getAllNames(): Set<String>
 }
 
-inline fun <E> buildSet(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> builderAction: MutableSet<E>.() -> Unit): Set<E> {
+inline fun <E> buildSet(@<!DEPRECATION, OPT_IN_USAGE_ERROR!>BuilderInference<!> builderAction: MutableSet<E>.() -> Unit): Set<E> {
     return null!!
 }
 

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java

@@ -19397,6 +19397,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/inference/builderInferenceLeakingVariable.kt");
         }
 
+        @Test
+        @TestMetadata("builderInferenceWithAnnotation.kt")
+        public void testBuilderInferenceWithAnnotation() throws Exception {
+            runTest("compiler/testData/codegen/box/inference/builderInferenceWithAnnotation.kt");
+        }
+
         @Test
         @TestMetadata("capturedStarProjection.kt")
         public void testCapturedStarProjection() throws Exception {

compiler/testData/codegen/box/coroutines/asyncIteratorNullMerge_1_3.kt

@@ -20,7 +20,7 @@ interface AsyncIterator<out T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> asyncGenerate(@BuilderInference block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequence<T> = object : AsyncSequence<T> {
+fun <T> asyncGenerate(block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequence<T> = object : AsyncSequence<T> {
     override fun iterator(): AsyncIterator<T> {
         val iterator = AsyncGeneratorIterator<T>()
         iterator.nextStep = block.createCoroutine(receiver = iterator, completion = iterator)

compiler/testData/codegen/box/coroutines/asyncIteratorToList_1_3.kt

@@ -20,7 +20,7 @@ interface AsyncIterator<out T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> asyncGenerate(@BuilderInference block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequence<T> = object : AsyncSequence<T> {
+fun <T> asyncGenerate(block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequence<T> = object : AsyncSequence<T> {
     override fun iterator(): AsyncIterator<T> {
         val iterator = AsyncGeneratorIterator<T>()
         iterator.nextStep = block.createCoroutine(receiver = iterator, completion = iterator)

compiler/testData/codegen/box/coroutines/asyncIterator_1_3.kt

@@ -20,7 +20,7 @@ interface AsyncIterator<out T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> asyncGenerate(@BuilderInference block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequence<T> = object : AsyncSequence<T> {
+fun <T> asyncGenerate(block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequence<T> = object : AsyncSequence<T> {
     override fun iterator(): AsyncIterator<T> {
         val iterator = AsyncGeneratorIterator<T>()
         iterator.nextStep = block.createCoroutine(receiver = iterator, completion = iterator)

compiler/testData/codegen/box/coroutines/builderInferenceAndGenericArrayAcessCall.kt

@@ -7,7 +7,7 @@ interface Foo<T>
 class FooImpl<T> : Foo<T>
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> myflow(@BuilderInference block: Foo<T>.() -> Unit): Foo<T> {
+fun <T> myflow(block: Foo<T>.() -> Unit): Foo<T> {
     val impl = FooImpl<T>()
     impl.block()
     return impl

compiler/testData/codegen/box/coroutines/emptyCommonConstraintSystemForCoroutineInferenceCall.kt

@@ -61,10 +61,10 @@ suspend inline fun hang(onCancellation: () -> Unit) {}
 fun <T> Flow<T>.flatMap(mapper: suspend (T) -> Flow<T>): Flow<T> = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = TODO()
+fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-inline fun <T, R> Flow<T>.flatMapLatest(@BuilderInference crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> = TODO()
+inline fun <T, R> Flow<T>.flatMapLatest(crossinline transform: suspend (value: T) -> Flow<R>): Flow<R> = TODO()
 
 interface Flow<out T>
 

compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt49294.kt

@@ -23,7 +23,7 @@ suspend fun <T> Flow<T>.toList(): List<T> {
     return destination
 }
 
-fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = SafeFlow(block)
+fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> = SafeFlow(block)
 
 private class SafeFlow<T>(private val block: suspend FlowCollector<T>.() -> Unit) : Flow<T> {
     override suspend fun collect(collector: FlowCollector<T>) {
@@ -31,7 +31,7 @@ private class SafeFlow<T>(private val block: suspend FlowCollector<T>.() -> Unit
     }
 }
 
-fun <T> channelFlow(@BuilderInference block: suspend SendChannel<T>.() -> Unit): Flow<T> =
+fun <T> channelFlow(block: suspend SendChannel<T>.() -> Unit): Flow<T> =
     ChannelFlowBuilder(block)
 
 private open class ChannelFlowBuilder<T>(

compiler/testData/codegen/box/coroutines/kt30858.kt

@@ -15,7 +15,7 @@ fun myLaunch(
 ) {}
 
 @OptIn(kotlin.experimental.ExperimentalTypeInference::class)
-public fun <E> myProduce(@BuilderInference block: suspend MyProducerScope<E>.() -> Unit) {}
+public fun <E> myProduce(block: suspend MyProducerScope<E>.() -> Unit) {}
 
 fun <T> MyReceiveChannel<T>.debounce(period: Long) {
     myProduce<Any> {

compiler/testData/codegen/box/coroutines/kt31784.kt

@@ -10,7 +10,7 @@ interface Builder<T : Any> {
     fun filter(filter: (T) -> Boolean)
 }
 
-fun <T : Any> build(@BuilderInference block: Builder<T>.() -> Unit): T {
+fun <T : Any> build(block: Builder<T>.() -> Unit): T {
     val o = object : Builder<T> {
         override fun filter(filter: (T) -> Boolean) {
 

compiler/testData/codegen/box/inference/builderInference.kt

@@ -21,7 +21,7 @@ interface LiveDataScope<T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> liveData(@BuilderInference block: suspend LiveDataScope<T>.() -> Unit): LiveData<T> = null!!
+fun <T> liveData(block: suspend LiveDataScope<T>.() -> Unit): LiveData<T> = null!!
 
 fun <Value> Flow<Value>.asLiveData() = liveData {
     collect(this::emit)

compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt

@@ -5,10 +5,10 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build(block: TestInterface<R>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build2(block: TestInterface<R>.() -> Unit) {}
 
 interface TestInterface<R> {
     fun emit(r: R)

compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt

@@ -13,10 +13,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build(block: TestInterface<R>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build2(block: TestInterface<R>.() -> Unit) {}
 
 class Inv<K>
 

compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt

@@ -13,10 +13,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1> build(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
+fun <R2> build2(block: TestInterface<R2>.() -> Unit) {}
 
 class In<in K>
 

compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt

@@ -14,10 +14,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1> build(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
+fun <R2> build2(block: TestInterface<R2>.() -> Unit) {}
 
 class Out<out K>
 

compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt

@@ -14,10 +14,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1> build(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
+fun <R2> build2(block: TestInterface<R2>.() -> Unit) {}
 
 class Inv<K>
 

compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt

@@ -17,10 +17,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build(block: TestInterface<R>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build2(block: TestInterface<R>.() -> Unit) {}
 
 class Inv<K>
 

compiler/testData/codegen/box/inference/builderInference/constraintsBetweenTwoStubVariables.kt

@@ -10,7 +10,7 @@ class Foo<K11, K22>(val key: K11) {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K1, K2> build(@kotlin.BuilderInference builder: Foo<K1, K2>.() -> Unit) {}
+fun <K1, K2> build(builder: Foo<K1, K2>.() -> Unit) {}
 
 fun run(x: Int) {
     build {

compiler/testData/codegen/box/inference/builderInference/cstBasedOnTwoBuilderInferenceLambda.kt

@@ -23,22 +23,22 @@ class B: A
 class C: A
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K> build1(@BuilderInference builderAction1: In<K>.() -> Unit, @BuilderInference builderAction2: In<K>.() -> Unit): K = 1 as K
+fun <K> build1(builderAction1: In<K>.() -> Unit, builderAction2: In<K>.() -> Unit): K = 1 as K
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K> build2(@BuilderInference builderAction1: In<K>.() -> Unit, @BuilderInference builderAction2: In<K>.() -> Unit): K = B() as K
+fun <K> build2(builderAction1: In<K>.() -> Unit, builderAction2: In<K>.() -> Unit): K = B() as K
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K> build3(@BuilderInference builderAction1: Out<K>.() -> Unit, @BuilderInference builderAction2: Out<K>.() -> Unit): K = 1 as K
+fun <K> build3(builderAction1: Out<K>.() -> Unit, builderAction2: Out<K>.() -> Unit): K = 1 as K
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K> build4(@BuilderInference builderAction1: Out<K>.() -> Unit, @BuilderInference builderAction2: Out<K>.() -> Unit): K = B() as K
+fun <K> build4(builderAction1: Out<K>.() -> Unit, builderAction2: Out<K>.() -> Unit): K = B() as K
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K> build5(@BuilderInference builderAction1: Inv<K>.() -> Unit, @BuilderInference builderAction2: Inv<K>.() -> Unit): K = 1 as K
+fun <K> build5(builderAction1: Inv<K>.() -> Unit, builderAction2: Inv<K>.() -> Unit): K = 1 as K
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K> build6(@BuilderInference builderAction1: Inv<K>.() -> Unit, @BuilderInference builderAction2: Inv<K>.() -> Unit): K = B() as K
+fun <K> build6(builderAction1: Inv<K>.() -> Unit, builderAction2: Inv<K>.() -> Unit): K = B() as K
 
 @OptIn(ExperimentalStdlibApi::class)
 fun box(): String {

compiler/testData/codegen/box/inference/builderInference/intersect.kt

@@ -13,10 +13,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1> build(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
+fun <R2> build2(block: TestInterface<R2>.() -> Unit) {}
 
 class In<in K>
 

compiler/testData/codegen/box/inference/builderInference/kt41164.kt

@@ -8,7 +8,7 @@ interface MyFlow<out T>
 
 fun <K> select(x: K, y: K): K = x
 @OptIn(ExperimentalTypeInference::class)
-fun <T> myCallbackFlow(@BuilderInference block: MyProducerScope<T>.() -> Unit): MyFlow<T> = null!!
+fun <T> myCallbackFlow(block: MyProducerScope<T>.() -> Unit): MyFlow<T> = null!!
 fun MyProducerScope<*>.myAwaitClose(block: () -> Unit = {}) {}
 fun <E> myEmptyFlow(): MyFlow<E> = null!!
 

compiler/testData/codegen/box/inference/builderInference/kt44241.kt

@@ -11,7 +11,7 @@ class Scope<K11, K22>(
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K1, K2> B<K1>.scoped(@kotlin.BuilderInference binder: Scope<K1, K2>.() -> Unit) {}
+fun <K1, K2> B<K1>.scoped(binder: Scope<K1, K2>.() -> Unit) {}
 
 fun run(x: B<A>) {
     x.scoped { emit(key) }

compiler/testData/codegen/box/inference/builderInference/kt45083.kt

@@ -6,7 +6,7 @@ object Hello {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <E> buildList0(@BuilderInference builder: MutableList<E>.() -> Unit): List<E> = mutableListOf<E>().apply { builder() }
+fun <E> buildList0(builder: MutableList<E>.() -> Unit): List<E> = mutableListOf<E>().apply { builder() }
 
 val numbers = buildList0 {
     add(Hello.let { it::hello }.get())

compiler/testData/codegen/box/inference/builderInference/kt47744.kt

@@ -4,10 +4,10 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit) = Flow<T>()
+fun <T> flow(block: suspend FlowCollector<T>.() -> Unit) = Flow<T>()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <E> produce(@BuilderInference block: suspend SendChannel<E>.() -> Unit) {}
+fun <E> produce(block: suspend SendChannel<E>.() -> Unit) {}
 
 interface SendChannel<in E> {
     val onSend: SelectClause2<E, SendChannel<E>>

compiler/testData/codegen/box/inference/builderInference/kt51988.kt

@@ -3,12 +3,12 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <AB1, BB1> build(@BuilderInference block: BuilderScope<AB1>.() -> BB1): ResultProvider<AB1, BB1> = object : ResultProvider<AB1, BB1> {
+fun <AB1, BB1> build(block: BuilderScope<AB1>.() -> BB1): ResultProvider<AB1, BB1> = object : ResultProvider<AB1, BB1> {
     override fun provideResult(): AB1 = "OK" as AB1
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <AB2, BB2> build2(@BuilderInference block: BuilderScope<AB2>.() -> BB2): ResultProvider<AB2, BB2> = object : ResultProvider<AB2, BB2> {
+fun <AB2, BB2> build2(block: BuilderScope<AB2>.() -> BB2): ResultProvider<AB2, BB2> = object : ResultProvider<AB2, BB2> {
     override fun provideResult(): AB2 = "OK" as AB2
 }
 

compiler/testData/codegen/box/inference/builderInference/labaledCall.kt

@@ -5,7 +5,7 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
+fun <R> build(block: TestInterface<R>.() -> Unit) {}
 
 interface TestInterface<R> {
     fun emit(r: R)

compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt

@@ -15,7 +15,7 @@ class Builder<T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> build(@BuilderInference configure: Builder<T>.() -> Unit) =
+fun <T> build(configure: Builder<T>.() -> Unit) =
     Builder<T>().apply(configure).build()
 
 fun box(): String {

compiler/testData/codegen/box/inference/builderInference/memberScope.kt

@@ -11,7 +11,7 @@ interface TestInterface<R> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1> build(block: TestInterface<R1>.() -> Unit) {}
 
 fun Any.test() {}
 fun Any?.test2() {}

compiler/testData/codegen/box/inference/builderInference/nullability.kt

@@ -11,16 +11,16 @@ interface TestInterface<R> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1> build(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1 : Any> build2(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1 : Any> build2(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1 : R2, R2 : Any> build3(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1 : R2, R2 : Any> build3(block: TestInterface<R1>.() -> Unit) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1 : R2, R2> build4(x: R2, @BuilderInference block: TestInterface<R1>.() -> Unit) {}
+fun <R1 : R2, R2> build4(x: R2, block: TestInterface<R1>.() -> Unit) {}
 
 fun test(a: String?) {
     val ret1 = build {

compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt

@@ -18,7 +18,7 @@ public interface ProducerScopeX<in E>   {
 public class FlowX<out T> {}
 
 @OptIn(ExperimentalTypeInference::class)
-public fun <T> callbackFlowX(@BuilderInference block: ProducerScopeX<T>.() -> Unit): FlowX<T> = FlowX()
+public fun <T> callbackFlowX(block: ProducerScopeX<T>.() -> Unit): FlowX<T> = FlowX()
 
 fun foo(): FlowX<String> = callbackFlowX {
     object : Callback {

compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferences.kt

@@ -14,7 +14,7 @@ fun <T> materialize() = null as T
 interface FlowCollector<in T> {}
 
 @Suppress("OPT_IN_USAGE_ERROR")
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt

@@ -31,7 +31,7 @@ fun foo7() = null as Foo7<Int>
 interface FlowCollector<in T> {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt

@@ -14,7 +14,7 @@ fun <T> materialize() = null as T
 interface FlowCollector<in T> {}
 
 @Suppress("OPT_IN_USAGE_ERROR")
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt

@@ -6,17 +6,17 @@ import kotlin.experimental.ExperimentalTypeInference
 
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> scopedFlow(@BuilderInference block: suspend CoroutineScope.(FlowCollector<R>) -> Unit): Flow<R> =
+fun <R> scopedFlow(block: suspend CoroutineScope.(FlowCollector<R>) -> Unit): Flow<R> =
     flow {
         val collector = this
         flowScope { block(collector) }
     }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit): Flow<T> = TODO()
+fun <T> flow(block: suspend FlowCollector<T>.() -> Unit): Flow<T> = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> flowScope(@BuilderInference block: suspend CoroutineScope.() -> R): R = TODO()
+fun <R> flowScope(block: suspend CoroutineScope.() -> R): R = TODO()
 
 interface CoroutineScope
 interface Flow<out T>

compiler/testData/codegen/box/inference/builderInference/specialCallsWithLambdas.kt

@@ -5,7 +5,7 @@ import kotlin.experimental.ExperimentalTypeInference
 interface FlowCollector<in T> {}
 
 @Suppress("OPT_IN_USAGE_ERROR")
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/codegen/box/inference/builderInference/substituteStubTypeIntolambdaParameterDescriptor.kt

@@ -8,7 +8,7 @@ class TypeDefinition<K : Any> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T : Any> defineType(@BuilderInference definition: TypeDefinition<T>.() -> Unit): Unit {}
+fun <T : Any> defineType(definition: TypeDefinition<T>.() -> Unit): Unit {}
 
 fun test() {
     defineType {

compiler/testData/codegen/box/inference/builderInference/substituteTypeVariableIntolambdaParameterDescriptor.kt

@@ -12,7 +12,7 @@ interface FlowCollector<T> {
 }
 
 @Suppress("OPT_IN_USAGE_ERROR")
-fun <I> flow(@BuilderInference block: FlowCollector<I>.() -> Unit): I = null as I
+fun <I> flow(block: FlowCollector<I>.() -> Unit): I = null as I
 
 fun adapt(): Unit = flow {
     emit(foo { coroutine -> bar(coroutine) })

compiler/testData/codegen/box/inference/builderInference/substitutelambdaExtensionReceiverType.kt

@@ -6,7 +6,7 @@ operator fun <T> SequenceScope<String>.plusAssign(x: SequenceScope<T>) {}
 
 @OptIn(ExperimentalTypeInference::class)
 
-fun <T> mySequence(@BuilderInference block: suspend SequenceScope<T>.() -> Unit): Sequence<T> = Sequence { iterator(block) }
+fun <T> mySequence(block: suspend SequenceScope<T>.() -> Unit): Sequence<T> = Sequence { iterator(block) }
 
 fun main() {
     val y: Sequence<String> = mySequence {

compiler/testData/codegen/box/inference/builderInference/topDownCompletionBreakedByNonBuilderInferenceSession.kt

@@ -5,17 +5,17 @@ import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
 class A1<T> {
-    fun <BT1> builder1(@BuilderInference configure: A2<BT1>.() -> Unit) {}
+    fun <BT1> builder1(configure: A2<BT1>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A2<A2_BT1> {
-    fun <BT2> builder2(@BuilderInference configure: A3<A2_BT1, BT2>.() -> Unit) {}
+    fun <BT2> builder2(configure: A3<A2_BT1, BT2>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A3<A3_BT1, A3_BT2> {
-    fun <BT3> builder3(@BuilderInference configure: A4<A3_BT1, A3_BT2, BT3>.() -> Unit) {}
+    fun <BT3> builder3(configure: A4<A3_BT1, A3_BT2, BT3>.() -> Unit) {}
 }
 
 class A4<A3_BT1, A3_BT2, A3_BT3> {

compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithThreeBuilderInferenceCalls.kt

@@ -5,17 +5,17 @@ import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
 class A1<T> {
-    fun <BT1> builder1(@BuilderInference configure: A2<BT1>.() -> Unit) {}
+    fun <BT1> builder1(configure: A2<BT1>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A2<A2_BT1> {
-    fun <BT2> builder2(@BuilderInference configure: A3<A2_BT1, BT2>.() -> Unit) {}
+    fun <BT2> builder2(configure: A3<A2_BT1, BT2>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A3<A3_BT1, A3_BT2> {
-    fun <BT3> builder3(@BuilderInference configure: A4<A3_BT1, A3_BT2, BT3>.() -> Unit) {}
+    fun <BT3> builder3(configure: A4<A3_BT1, A3_BT2, BT3>.() -> Unit) {}
 }
 
 class A4<A3_BT1, A3_BT2, A3_BT3> {

compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithThreeBuilderInferenceCallsSameLevel.kt

@@ -5,17 +5,17 @@ import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
 class A1<T> {
-    fun <BT1> builder1(@BuilderInference configure: A2<BT1>.() -> Unit) {}
+    fun <BT1> builder1(configure: A2<BT1>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A2<A2_BT1> {
-    fun <BT2> builder2(@BuilderInference configure: A3<A2_BT1, BT2>.() -> Unit) {}
+    fun <BT2> builder2(configure: A3<A2_BT1, BT2>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A3<A3_BT1, A3_BT2> {
-    fun <BT3> builder3(@BuilderInference configure: A4<A3_BT1, A3_BT2, BT3>.() -> Unit) {}
+    fun <BT3> builder3(configure: A4<A3_BT1, A3_BT2, BT3>.() -> Unit) {}
 }
 
 class A4<A3_BT1, A3_BT2, A3_BT3> {

compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt

@@ -5,12 +5,12 @@ import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
 class A1<T> {
-    fun <BT1> builder1(@BuilderInference configure: A2<BT1>.() -> Unit) {}
+    fun <BT1> builder1(configure: A2<BT1>.() -> Unit) {}
 }
 
 @OptIn(ExperimentalTypeInference::class)
 class A2<A2_BT1> {
-    fun <BT2> builder2(@BuilderInference configure: A3<A2_BT1, BT2>.() -> Unit) {}
+    fun <BT2> builder2(configure: A3<A2_BT1, BT2>.() -> Unit) {}
 }
 
 class A3<A3_BT1, A3_BT2> {

compiler/testData/codegen/box/inference/builderInferenceLeakingVariable.kt

@@ -12,7 +12,7 @@ class InImpl<E>(val block: suspend In<E>.() -> Unit) : In<E> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-public fun <T> builder(@BuilderInference block: suspend In<T>.() -> Unit) {
+public fun <T> builder(block: suspend In<T>.() -> Unit) {
     InImpl(block)
 }
 

compiler/testData/codegen/box/inference/builderInferenceWithAnnotation.kt

@@ -0,0 +1,31 @@
+// TARGET_BACKEND: JVM
+// WITH_STDLIB
+// ISSUE: KT-33545
+
+import kotlin.experimental.ExperimentalTypeInference
+
+interface Flow<out T> {
+    suspend fun collect(collector: FlowCollector<T>)
+}
+
+interface FlowCollector<in T> {
+    suspend fun emit(value: T)
+}
+
+inline fun <T> Flow<T>.collect(crossinline action: suspend (value: T) -> Unit): Unit {}
+
+abstract class LiveData<T>
+
+interface LiveDataScope<T> {
+    suspend fun emit(value: T)
+}
+
+@OptIn(ExperimentalTypeInference::class)
+fun <T> liveData(@BuilderInference block: suspend LiveDataScope<T>.() -> Unit): LiveData<T> = null!!
+
+fun <Value> Flow<Value>.asLiveData() = liveData {
+    collect(this::emit)
+//    collect { emit(it) }
+}
+
+fun box(): String = "OK"

compiler/testData/codegen/box/inference/kt35684.kt

@@ -13,7 +13,7 @@ fun test() {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <U> sequence(@BuilderInference block: suspend Inv<U>.() -> Unit) {}
+fun <U> sequence(block: suspend Inv<U>.() -> Unit) {}
 
 interface Inv<T> {
     fun yield(element: T)

compiler/testData/codegen/box/inference/kt36446.kt

@@ -28,7 +28,7 @@ class ConversionBuilder<Value> {
 }
 class DefinitionBuilder<Transaction> {
     @OptIn(ExperimentalTypeInference::class)
-    fun <Value> conversion(@BuilderInference configure: ConversionBuilder<Value>.() -> Unit): Unit {}
+    fun <Value> conversion(configure: ConversionBuilder<Value>.() -> Unit): Unit {}
 }
 interface ArgumentDefinition<Value> {
     operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): ArgumentReference<Value>

compiler/testData/codegen/box/inference/mapCollectChainWithNullResult.kt

@@ -20,7 +20,7 @@ fun <T> Flow<T>.collect(action: (value: T) -> Unit): Unit =
         override fun emit(value: T) = action(value)
     })
 
-fun <T, R> Flow<T>.transform(@BuilderInference transform: FlowCollector<R>.(T) -> Unit): Flow<R> =
+fun <T, R> Flow<T>.transform(transform: FlowCollector<R>.(T) -> Unit): Flow<R> =
     flow { collect { transform(it) } }
 
 fun <T, R> Flow<T>.map(transform: (T) -> R): Flow<R> =

compiler/testData/codegen/box/inference/plusAssignInsideLambda.kt

@@ -7,7 +7,7 @@ interface SendChannel<in T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-public fun <T> flux(@BuilderInference block: suspend SendChannel<T>.() -> Unit) {}
+public fun <T> flux(block: suspend SendChannel<T>.() -> Unit) {}
 
 suspend inline fun <T> T.collect(action: (T) -> Unit) { action(this) }
 

compiler/testData/codegen/bytecodeListing/coroutines/spilling/select.kt

@@ -8,7 +8,7 @@ interface CoroutineScope
 
 @OptIn(ExperimentalTypeInference::class)
 public fun <E> CoroutineScope.produce(
-    @BuilderInference block: suspend ProducerScope<E>.() -> Unit
+    block: suspend ProducerScope<E>.() -> Unit
 ): ReceiveChannel<E>  = TODO()
 
 interface ProducerScope<in E> : CoroutineScope, SendChannel<E> {

compiler/testData/codegen/bytecodeListing/coroutines/spilling/select.txt

@@ -56,7 +56,7 @@ final class SelectKt$produceNumbers$1 {
 public final class SelectKt {
     // source: 'select.kt'
     inner (anonymous) class SelectKt$produceNumbers$1
-    public final static @org.jetbrains.annotations.NotNull method produce(@org.jetbrains.annotations.NotNull p0: CoroutineScope, @kotlin.BuilderInference @org.jetbrains.annotations.NotNull p1: kotlin.jvm.functions.Function2): ReceiveChannel
+    public final static @org.jetbrains.annotations.NotNull method produce(@org.jetbrains.annotations.NotNull p0: CoroutineScope, @org.jetbrains.annotations.NotNull p1: kotlin.jvm.functions.Function2): ReceiveChannel
     public final static @org.jetbrains.annotations.NotNull method produceNumbers(@org.jetbrains.annotations.NotNull p0: CoroutineScope, @org.jetbrains.annotations.NotNull p1: SendChannel): ReceiveChannel
     private final static @org.jetbrains.annotations.Nullable method select$$forInline(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
     public final static @org.jetbrains.annotations.Nullable method select(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object

compiler/testData/codegen/bytecodeText/coroutines/debug/localVariableCorrectLabel.kt

@@ -11,7 +11,6 @@ fun main(args: Array<String>) {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-@BuilderInference
 suspend fun SequenceScope<Int>.awaitSeq(): Int = 42
 
 // JVM_IR_TEMPLATES

compiler/testData/diagnostics/tests/inference/builderInference/changingResolveIfDontUseBuilderInference.fir.kt

@@ -5,14 +5,14 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K, V> buildMap(@BuilderInference builderAction: MutableMap<K, V>.() -> Unit): Map<K, V> = mapOf()
+fun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V> = mapOf()
 
 fun foo(): MutableMap<CharSequence, *> = mutableMapOf<CharSequence, String>()
 
 fun <E> MutableMap<E, *>.swap(x: MutableMap<E, *>) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K : V, V : CharSequence> build7(@BuilderInference builderAction: MutableMap<K, V>.() -> MutableMap<String, V>) = mutableMapOf<String, V>()
+fun <K : V, V : CharSequence> build7(builderAction: MutableMap<K, V>.() -> MutableMap<String, V>) = mutableMapOf<String, V>()
 
 fun <K> id(x: K): K = x
 

compiler/testData/diagnostics/tests/inference/builderInference/changingResolveIfDontUseBuilderInference.kt

@@ -5,14 +5,14 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K, V> buildMap(@BuilderInference builderAction: MutableMap<K, V>.() -> Unit): Map<K, V> = mapOf()
+fun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V> = mapOf()
 
 fun foo(): MutableMap<CharSequence, *> = mutableMapOf<CharSequence, String>()
 
 fun <E> MutableMap<E, *>.swap(x: MutableMap<E, *>) {}
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K : V, V : CharSequence> build7(@BuilderInference builderAction: MutableMap<K, V>.() -> MutableMap<String, V>) = mutableMapOf<String, V>()
+fun <K : V, V : CharSequence> build7(builderAction: MutableMap<K, V>.() -> MutableMap<String, V>) = mutableMapOf<String, V>()
 
 fun <K> id(x: K): K = x
 

compiler/testData/diagnostics/tests/inference/builderInference/changingResolveIfDontUseBuilderInference.txt

@@ -1,7 +1,7 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K : V, /*1*/ V : kotlin.CharSequence> build7(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap<K, V>.() -> kotlin.collections.MutableMap<kotlin.String, V>): kotlin.collections.MutableMap<kotlin.String, V>
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K, /*1*/ V> buildMap(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap<K, V>.() -> kotlin.Unit): kotlin.collections.Map<K, V>
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K : V, /*1*/ V : kotlin.CharSequence> build7(/*0*/ builderAction: kotlin.collections.MutableMap<K, V>.() -> kotlin.collections.MutableMap<kotlin.String, V>): kotlin.collections.MutableMap<kotlin.String, V>
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K, /*1*/ V> buildMap(/*0*/ builderAction: kotlin.collections.MutableMap<K, V>.() -> kotlin.Unit): kotlin.collections.Map<K, V>
 public fun foo(): kotlin.collections.MutableMap<kotlin.CharSequence, *>
 public fun </*0*/ K> id(/*0*/ x: K): K
 @kotlin.OptIn(markerClass = {kotlin.ExperimentalStdlibApi::class}) public fun main(): kotlin.Unit

compiler/testData/diagnostics/tests/inference/builderInference/kt47744.fir.kt

@@ -5,10 +5,10 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit) = Flow<T>()
+fun <T> flow(block: suspend FlowCollector<T>.() -> Unit) = Flow<T>()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <E> produce(@BuilderInference block: suspend SendChannel<E>.() -> Unit) {}
+fun <E> produce(block: suspend SendChannel<E>.() -> Unit) {}
 
 interface SendChannel<in E> {
     val onSend: SelectClause2<E, SendChannel<E>>

compiler/testData/diagnostics/tests/inference/builderInference/kt47744.kt

@@ -5,10 +5,10 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> flow(@BuilderInference block: suspend FlowCollector<T>.() -> Unit) = Flow<T>()
+fun <T> flow(block: suspend FlowCollector<T>.() -> Unit) = Flow<T>()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <E> produce(@BuilderInference block: suspend SendChannel<E>.() -> Unit) {}
+fun <E> produce(block: suspend SendChannel<E>.() -> Unit) {}
 
 interface SendChannel<in E> {
     val onSend: SelectClause2<E, SendChannel<E>>

compiler/testData/diagnostics/tests/inference/builderInference/kt47744.txt

@@ -1,7 +1,7 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ T> flow(/*0*/ @kotlin.BuilderInference block: suspend FlowCollector<T>.() -> kotlin.Unit): Flow<T>
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ E> produce(/*0*/ @kotlin.BuilderInference block: suspend SendChannel<E>.() -> kotlin.Unit): kotlin.Unit
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ T> flow(/*0*/ block: suspend FlowCollector<T>.() -> kotlin.Unit): Flow<T>
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ E> produce(/*0*/ block: suspend SendChannel<E>.() -> kotlin.Unit): kotlin.Unit
 public inline fun </*0*/ R> select(/*0*/ crossinline builder: SelectBuilder<R>.() -> kotlin.Unit): R
 public fun test(): kotlin.Unit
 

compiler/testData/diagnostics/tests/inference/builderInference/kt49285.fir.kt

@@ -7,10 +7,10 @@ class Foo<T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K1> myBuilder1(@BuilderInference builder: Foo<K1>.() -> Foo<K1>): Foo<K1> = Foo<K1>().apply { builder() }
+fun <K1> myBuilder1(builder: Foo<K1>.() -> Foo<K1>): Foo<K1> = Foo<K1>().apply { builder() }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K2> myBuilder2(@BuilderInference builder: Foo<K2>.() -> Unit): Foo<K2> = Foo<K2>().apply(builder)
+fun <K2> myBuilder2(builder: Foo<K2>.() -> Unit): Foo<K2> = Foo<K2>().apply(builder)
 
 val result1 = myBuilder1 {
     add(null)

compiler/testData/diagnostics/tests/inference/builderInference/kt49285.kt

@@ -7,10 +7,10 @@ class Foo<T> {
 }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K1> myBuilder1(@BuilderInference builder: Foo<K1>.() -> Foo<K1>): Foo<K1> = Foo<K1>().apply { builder() }
+fun <K1> myBuilder1(builder: Foo<K1>.() -> Foo<K1>): Foo<K1> = Foo<K1>().apply { builder() }
 
 @OptIn(ExperimentalTypeInference::class)
-fun <K2> myBuilder2(@BuilderInference builder: Foo<K2>.() -> Unit): Foo<K2> = Foo<K2>().apply(builder)
+fun <K2> myBuilder2(builder: Foo<K2>.() -> Unit): Foo<K2> = Foo<K2>().apply(builder)
 
 val result1 = myBuilder1 {
     add(null)

compiler/testData/diagnostics/tests/inference/builderInference/kt49285.txt

@@ -1,8 +1,8 @@
 package
 
 public val result1: Foo<kotlin.Nothing?>
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K1> myBuilder1(/*0*/ @kotlin.BuilderInference builder: Foo<K1>.() -> Foo<K1>): Foo<K1>
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K2> myBuilder2(/*0*/ @kotlin.BuilderInference builder: Foo<K2>.() -> kotlin.Unit): Foo<K2>
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K1> myBuilder1(/*0*/ builder: Foo<K1>.() -> Foo<K1>): Foo<K1>
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ K2> myBuilder2(/*0*/ builder: Foo<K2>.() -> kotlin.Unit): Foo<K2>
 
 public final class Foo</*0*/ T> {
     public constructor Foo</*0*/ T>()

compiler/testData/diagnostics/tests/inference/builderInference/kt49828.fir.kt

@@ -201,7 +201,7 @@ interface Foo2<K, V> {
     fun entries(): MutableSet<MutableMap.MutableEntry<K, V>>
 }
 
-fun <L, K, V> twoBuilderLambdas(@BuilderInference block: Foo<L>.() -> Unit, @BuilderInference block2: Foo2<K, V>.() -> Unit) {}
+fun <L, K, V> twoBuilderLambdas(block: Foo<L>.() -> Unit, block2: Foo2<K, V>.() -> Unit) {}
 
 fun test() {
     twoBuilderLambdas(

compiler/testData/diagnostics/tests/inference/builderInference/kt49828.kt

@@ -201,7 +201,7 @@ interface Foo2<K, V> {
     fun entries(): MutableSet<MutableMap.MutableEntry<K, V>>
 }
 
-fun <L, K, V> twoBuilderLambdas(@BuilderInference block: Foo<L>.() -> Unit, @BuilderInference block2: Foo2<K, V>.() -> Unit) {}
+fun <L, K, V> twoBuilderLambdas(block: Foo<L>.() -> Unit, block2: Foo2<K, V>.() -> Unit) {}
 
 fun test() {
     twoBuilderLambdas(
@@ -209,13 +209,13 @@ fun test() {
             add("")
             with (get()) {
                 with (listOf(1)) {
-                    <!STUB_TYPE_IN_RECEIVER_CAUSES_AMBIGUITY("String; L; String; LAMBDA_EXPRESSION")!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OVERLOAD_RESOLUTION_AMBIGUITY, OVERLOAD_RESOLUTION_AMBIGUITY_BECAUSE_OF_STUB_TYPES!>bar<!>()<!>
+                    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>()
                 }
             }
         },
         {
             put(1, "one")
-            <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OVERLOAD_RESOLUTION_AMBIGUITY, OVERLOAD_RESOLUTION_AMBIGUITY_BECAUSE_OF_STUB_TYPES!>foo11<!>(<!STUB_TYPE_IN_ARGUMENT_CAUSES_AMBIGUITY("MutableSet<MutableMap.MutableEntry<Int, String>>; K, V; Int, String")!>entries()<!>)
+            <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OVERLOAD_RESOLUTION_AMBIGUITY!>foo11<!>(entries())
         }
     )
 }

compiler/testData/diagnostics/tests/inference/builderInference/kt49828.txt

@@ -19,7 +19,7 @@ public fun foo11(/*0*/ x: kotlin.collections.MutableSet<kotlin.collections.Mutab
 @kotlin.jvm.JvmName(name = "foo111") public fun foo11(/*0*/ x: kotlin.collections.MutableSet<kotlin.collections.MutableMap.MutableEntry<kotlin.String, kotlin.Int>>): kotlin.Unit
 public fun main(): kotlin.Unit
 public fun test(): kotlin.Unit
-public fun </*0*/ L, /*1*/ K, /*2*/ V> twoBuilderLambdas(/*0*/ @kotlin.BuilderInference block: Foo<L>.() -> kotlin.Unit, /*1*/ @kotlin.BuilderInference block2: Foo2<K, V>.() -> kotlin.Unit): kotlin.Unit
+public fun </*0*/ L, /*1*/ K, /*2*/ V> twoBuilderLambdas(/*0*/ block: Foo<L>.() -> kotlin.Unit, /*1*/ block2: Foo2<K, V>.() -> kotlin.Unit): kotlin.Unit
 public fun kotlin.Int.bar(): kotlin.Unit
 @kotlin.jvm.JvmName(name = "bar1") public fun kotlin.String.bar(): kotlin.Unit
 public fun kotlin.Int.foo0003(/*0*/ y: kotlin.Number, /*1*/ z: kotlin.String): kotlin.Unit

compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.kt

@@ -6,7 +6,7 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(block: TestInterface<R>.() -> Unit): R = TODO()
 
 interface TestInterface<R> {
     fun emit(r: R)

compiler/testData/diagnostics/tests/inference/builderInference/labaledCall.txt

@@ -1,6 +1,6 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build(/*0*/ @kotlin.BuilderInference block: TestInterface<R>.() -> kotlin.Unit): R
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build(/*0*/ block: TestInterface<R>.() -> kotlin.Unit): R
 public fun main(): kotlin.Unit
 
 public interface TestInterface</*0*/ R> {

compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt

@@ -7,7 +7,7 @@ import kotlin.experimental.ExperimentalTypeInference
 @OptIn(ExperimentalTypeInference::class)
 fun <R> combined(
     check: () -> Unit,
-    @BuilderInference block: TestInterface<R>.() -> Unit
+    block: TestInterface<R>.() -> Unit
 ): R = TODO()
 
 interface TestInterface<R> {

compiler/testData/diagnostics/tests/inference/builderInference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.txt

@@ -1,6 +1,6 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> combined(/*0*/ check: () -> kotlin.Unit, /*1*/ @kotlin.BuilderInference block: TestInterface<R>.() -> kotlin.Unit): R
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> combined(/*0*/ check: () -> kotlin.Unit, /*1*/ block: TestInterface<R>.() -> kotlin.Unit): R
 public fun test(): kotlin.Unit
 
 public interface TestInterface</*0*/ R> {

compiler/testData/diagnostics/tests/inference/builderInference/skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt

@@ -5,7 +5,7 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <T> foo(x: T, @BuilderInference builder: T.() -> Unit): Unit = TODO()
+fun <T> foo(x: T, builder: T.() -> Unit): Unit = TODO()
 
 class Bar<T>
 

compiler/testData/diagnostics/tests/inference/builderInference/skipedUnresolvedInBuilderInferenceWithStubReceiverType.txt

@@ -1,6 +1,6 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ T> foo(/*0*/ x: T, /*1*/ @kotlin.BuilderInference builder: T.() -> kotlin.Unit): kotlin.Unit
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ T> foo(/*0*/ x: T, /*1*/ builder: T.() -> kotlin.Unit): kotlin.Unit
 public fun test(): kotlin.Unit
 
 public final class Bar</*0*/ T> {

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.fir.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt

@@ -30,7 +30,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.fir.kt

@@ -31,7 +31,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt

@@ -31,7 +31,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.fir.kt

@@ -16,7 +16,7 @@ var foo4: Float
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt

@@ -16,7 +16,7 @@ var foo4: Float
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt

@@ -32,7 +32,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt

@@ -32,7 +32,7 @@ fun foo7() = null as Foo7<Int>
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit): Flow<L> = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.fir.kt

@@ -6,7 +6,7 @@ import kotlin.experimental.ExperimentalTypeInference
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.kt

@@ -6,7 +6,7 @@ import kotlin.experimental.ExperimentalTypeInference
 
 interface FlowCollector<in T> {}
 
-fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
+fun <L> flow(block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
 
 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.fir.kt

@@ -6,10 +6,10 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(block: TestInterface<R>.() -> Unit): R = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build2(block: TestInterface<R>.() -> Unit): R = TODO()
 
 interface TestInterface<R> {
     fun emit(r: R)

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt

@@ -6,10 +6,10 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(block: TestInterface<R>.() -> Unit): R = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build2(block: TestInterface<R>.() -> Unit): R = TODO()
 
 interface TestInterface<R> {
     fun emit(r: R)

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.txt

@@ -1,7 +1,7 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build(/*0*/ @kotlin.BuilderInference block: TestInterface<R>.() -> kotlin.Unit): R
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build2(/*0*/ @kotlin.BuilderInference block: TestInterface<R>.() -> kotlin.Unit): R
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build(/*0*/ block: TestInterface<R>.() -> kotlin.Unit): R
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build2(/*0*/ block: TestInterface<R>.() -> kotlin.Unit): R
 public fun </*0*/ K> capture(/*0*/ x: Inv<K>): K
 public fun </*0*/ K> captureIn(/*0*/ x: Inv<out K>): K
 public fun </*0*/ K> captureOut(/*0*/ x: Inv<out K>): K

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.fir.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(block: TestInterface<R>.() -> Unit): R = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build2(block: TestInterface<R>.() -> Unit): R = TODO()
 
 class Inv<K>
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(block: TestInterface<R>.() -> Unit): R = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build2(block: TestInterface<R>.() -> Unit): R = TODO()
 
 class Inv<K>
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.txt

@@ -1,7 +1,7 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build(/*0*/ @kotlin.BuilderInference block: TestInterface<R>.() -> kotlin.Unit): R
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build2(/*0*/ @kotlin.BuilderInference block: TestInterface<R>.() -> kotlin.Unit): R
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build(/*0*/ block: TestInterface<R>.() -> kotlin.Unit): R
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R> build2(/*0*/ block: TestInterface<R>.() -> kotlin.Unit): R
 public fun </*0*/ U> id(/*0*/ x: U): U
 public fun </*0*/ E> select(/*0*/ vararg x: E /*kotlin.Array<out E>*/): E
 public fun test(): kotlin.Unit

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.fir.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit): R1 = TODO()
+fun <R1> build(block: TestInterface<R1>.() -> Unit): R1 = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit): R2 = TODO()
+fun <R2> build2(block: TestInterface<R2>.() -> Unit): R2 = TODO()
 
 class In<in K>
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit): R1 = TODO()
+fun <R1> build(block: TestInterface<R1>.() -> Unit): R1 = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit): R2 = TODO()
+fun <R2> build2(block: TestInterface<R2>.() -> Unit): R2 = TODO()
 
 class In<in K>
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeContravariant.txt

@@ -1,7 +1,7 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R1> build(/*0*/ @kotlin.BuilderInference block: TestInterface<R1>.() -> kotlin.Unit): R1
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R2> build2(/*0*/ @kotlin.BuilderInference block: TestInterface<R2>.() -> kotlin.Unit): R2
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R1> build(/*0*/ block: TestInterface<R1>.() -> kotlin.Unit): R1
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R2> build2(/*0*/ block: TestInterface<R2>.() -> kotlin.Unit): R2
 public fun </*0*/ U> id(/*0*/ x: U): U?
 public fun </*0*/ E> select1(/*0*/ x: E, /*1*/ y: In<E>): E?
 public fun </*0*/ E> select2(/*0*/ x: E, /*1*/ y: In<E?>): E

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.fir.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit): R1 = TODO()
+fun <R1> build(block: TestInterface<R1>.() -> Unit): R1 = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit): R2 = TODO()
+fun <R2> build2(block: TestInterface<R2>.() -> Unit): R2 = TODO()
 
 class Out<out K>
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit): R1 = TODO()
+fun <R1> build(block: TestInterface<R1>.() -> Unit): R1 = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit): R2 = TODO()
+fun <R2> build2(block: TestInterface<R2>.() -> Unit): R2 = TODO()
 
 class Out<out K>
 

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.txt

@@ -1,7 +1,7 @@
 package
 
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R1> build(/*0*/ @kotlin.BuilderInference block: TestInterface<R1>.() -> kotlin.Unit): R1
-@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R2> build2(/*0*/ @kotlin.BuilderInference block: TestInterface<R2>.() -> kotlin.Unit): R2
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R1> build(/*0*/ block: TestInterface<R1>.() -> kotlin.Unit): R1
+@kotlin.OptIn(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ R2> build2(/*0*/ block: TestInterface<R2>.() -> kotlin.Unit): R2
 public fun </*0*/ U> id(/*0*/ x: U): U?
 public fun </*0*/ E> select1(/*0*/ x: E, /*1*/ y: Out<E>): E?
 public fun </*0*/ E> select2(/*0*/ x: E, /*1*/ y: Out<E?>): E

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt

@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit): R1 = TODO()
+fun <R1> build(block: TestInterface<R1>.() -> Unit): R1 = TODO()
 
 @OptIn(ExperimentalTypeInference::class)
-fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit): R2 = TODO()
+fun <R2> build2(block: TestInterface<R2>.() -> Unit): R2 = TODO()
 
 class Inv<K>