Add addtional tests for builder inference

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.fir.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: +StableBuilderInference
+// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+@file:OptIn(ExperimentalTypeInference::class)
+
+import kotlin.experimental.ExperimentalTypeInference
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+    fun notYield(t: T) {}
+
+    suspend fun yieldBarReturnType(t: T) = t
+    fun barReturnType(): T = TODO()
+}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val test1 = generate {
+    yield(3)
+}
+
+val test2 = generate {
+    yield(3)
+    notYield(3)
+}
+
+val test3 = generate {
+    yield(3)
+    yieldBarReturnType(3)
+}
+
+val test4 = generate {
+    yield(3)
+    barReturnType()
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +StableBuilderInference
+// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+@file:OptIn(ExperimentalTypeInference::class)
+
+import kotlin.experimental.ExperimentalTypeInference
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+    fun notYield(t: T) {}
+
+    suspend fun yieldBarReturnType(t: T) = t
+    fun barReturnType(): T = TODO()
+}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val test1 = generate {
+    yield(3)
+}
+
+val test2 = generate {
+    yield(3)
+    notYield(3)
+}
+
+val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield(3)
+    yieldBarReturnType(3)
+}
+
+val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield(3)
+    barReturnType()
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCalls.txt

@@ -0,0 +1,18 @@
+package
+
+public val test1: kotlin.collections.List<kotlin.Int>
+public val test2: kotlin.collections.List<kotlin.Int>
+public val test3: kotlin.collections.List<kotlin.Int>
+public val test4: kotlin.collections.List<kotlin.Int>
+public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+
+public final class GenericController</*0*/ T> {
+    public constructor GenericController</*0*/ T>()
+    public final fun barReturnType(): T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun notYield(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public final suspend fun yield(/*0*/ t: T): kotlin.Unit
+    public final suspend fun yieldBarReturnType(/*0*/ t: T): T
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.fir.kt

@@ -0,0 +1,35 @@
+// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+
+@file:OptIn(ExperimentalTypeInference::class)
+
+import kotlin.experimental.ExperimentalTypeInference
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+    fun notYield(t: T) {}
+
+    suspend fun yieldBarReturnType(t: T) = t
+    fun barReturnType(): T = TODO()
+}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val test1 = generate {
+    yield(3)
+}
+
+val test2 = generate {
+    yield(3)
+    notYield(3)
+}
+
+val test3 = generate {
+    yield(3)
+    yieldBarReturnType(3)
+}
+
+val test4 = generate {
+    yield(3)
+    barReturnType()
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.kt

@@ -0,0 +1,36 @@
+// !USE_EXPERIMENTAL: kotlin.RequiresOptIn
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+@file:OptIn(ExperimentalTypeInference::class)
+
+import kotlin.experimental.ExperimentalTypeInference
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+    fun notYield(t: T) {}
+
+    suspend fun yieldBarReturnType(t: T) = t
+    fun barReturnType(): T = TODO()
+}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val test1 = generate {
+    yield(3)
+}
+
+val test2 = generate {
+    yield(3)
+    notYield(3)
+}
+
+val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
+    yield(3)
+    yieldBarReturnType(3)
+}
+
+val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
+    yield(3)
+    barReturnType()
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.txt

@@ -0,0 +1,24 @@
+package
+
+public val test1: kotlin.collections.List<kotlin.Int>
+public val test2: kotlin.collections.List<kotlin.Int>
+public val test3: [ERROR : Type for generate {
+    yield(3)
+    yieldBarReturnType(3)
+}]
+public val test4: [ERROR : Type for generate {
+    yield(3)
+    barReturnType()
+}]
+public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+
+public final class GenericController</*0*/ T> {
+    public constructor GenericController</*0*/ T>()
+    public final fun barReturnType(): T
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun notYield(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public final suspend fun yield(/*0*/ t: T): kotlin.Unit
+    public final suspend fun yieldBarReturnType(/*0*/ t: T): T
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/inferCoroutineTypeInOldVersion.fir.kt

@@ -0,0 +1,29 @@
+// !LANGUAGE: +StableBuilderInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Builder<T> {
+    suspend fun add(t: T) {}
+}
+
+fun <S> build(g: suspend Builder<S>.() -> Unit): List<S> = TODO()
+fun <S> wrongBuild(g: Builder<S>.() -> Unit): List<S> = TODO()
+
+fun <S> Builder<S>.extensionAdd(s: S) {}
+
+suspend fun <S> Builder<S>.safeExtensionAdd(s: S) {}
+
+val member = build {
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
+}
+
+val memberWithoutAnn = wrongBuild {
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
+}
+
+val extension = build {
+    extensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
+}
+
+val safeExtension = build {
+    safeExtensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/inferCoroutineTypeInOldVersion.kt

@@ -0,0 +1,29 @@
+// !LANGUAGE: +StableBuilderInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Builder<T> {
+    suspend fun add(t: T) {}
+}
+
+fun <S> build(g: suspend Builder<S>.() -> Unit): List<S> = TODO()
+fun <S> wrongBuild(g: Builder<S>.() -> Unit): List<S> = TODO()
+
+fun <S> Builder<S>.extensionAdd(s: S) {}
+
+suspend fun <S> Builder<S>.safeExtensionAdd(s: S) {}
+
+val member = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    add(42)
+}
+
+val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
+    <!ILLEGAL_SUSPEND_FUNCTION_CALL!>add<!>(42)
+}
+
+val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    extensionAdd("foo")
+}
+
+val safeExtension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    safeExtensionAdd("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/inferCoroutineTypeInOldVersion.txt

@@ -0,0 +1,26 @@
+package
+
+public val extension: [ERROR : Type for build {
+    extensionAdd("foo")
+}]
+public val member: [ERROR : Type for build {
+    add(42)
+}]
+public val memberWithoutAnn: [ERROR : Type for wrongBuild {
+    add(42)
+}]
+public val safeExtension: [ERROR : Type for build {
+    safeExtensionAdd("foo")
+}]
+public fun </*0*/ S> build(/*0*/ g: suspend Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public fun </*0*/ S> wrongBuild(/*0*/ g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public fun </*0*/ S> Builder<S>.extensionAdd(/*0*/ s: S): kotlin.Unit
+public suspend fun </*0*/ S> Builder<S>.safeExtensionAdd(/*0*/ s: S): kotlin.Unit
+
+public final class Builder</*0*/ T> {
+    public constructor Builder</*0*/ T>()
+    public final suspend fun add(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.fir.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: +StableBuilderInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class Builder<T> {
+    fun add(t: T) {}
+}
+
+fun <S> build(@BuilderInference g: Builder<S>.() -> Unit): List<S> = TODO()
+fun <S> wrongBuild(g: Builder<S>.() -> Unit): List<S> = TODO()
+
+fun <S> Builder<S>.extensionAdd(s: S) {}
+
+@BuilderInference
+fun <S> Builder<S>.safeExtensionAdd(s: S) {}
+
+val member = build {
+    add(42)
+}
+
+val memberWithoutAnn = wrongBuild {
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
+}
+
+val extension = build {
+    extensionAdd("foo")
+}
+
+val safeExtension = build {
+    safeExtensionAdd("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: +StableBuilderInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class Builder<T> {
+    fun add(t: T) {}
+}
+
+fun <S> build(@BuilderInference g: Builder<S>.() -> Unit): List<S> = TODO()
+fun <S> wrongBuild(g: Builder<S>.() -> Unit): List<S> = TODO()
+
+fun <S> Builder<S>.extensionAdd(s: S) {}
+
+@BuilderInference
+fun <S> Builder<S>.safeExtensionAdd(s: S) {}
+
+val member = build {
+    add(42)
+}
+
+val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
+    add(42)
+}
+
+val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    extensionAdd("foo")
+}
+
+val safeExtension = build {
+    safeExtensionAdd("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInference.txt

@@ -0,0 +1,30 @@
+package
+
+public val extension: kotlin.collections.List<kotlin.String>
+public val member: kotlin.collections.List<kotlin.Int>
+public val memberWithoutAnn: [ERROR : Type for wrongBuild {
+    add(42)
+}]
+public val safeExtension: kotlin.collections.List<kotlin.String>
+public fun </*0*/ S> build(/*0*/ @kotlin.BuilderInference g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public fun </*0*/ S> wrongBuild(/*0*/ g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public fun </*0*/ S> Builder<S>.extensionAdd(/*0*/ s: S): kotlin.Unit
+@kotlin.BuilderInference public fun </*0*/ S> Builder<S>.safeExtensionAdd(/*0*/ s: S): kotlin.Unit
+
+public final class Builder</*0*/ T> {
+    public constructor Builder</*0*/ T>()
+    public final fun add(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package kotlin {
+
+    public final annotation class BuilderInference : kotlin.Annotation {
+        public constructor BuilderInference()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.fir.kt

@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class Builder<T> {
+    fun add(t: T) {}
+}
+
+fun <S> build(@BuilderInference g: Builder<S>.() -> Unit): List<S> = TODO()
+fun <S> wrongBuild(g: Builder<S>.() -> Unit): List<S> = TODO()
+
+fun <S> Builder<S>.extensionAdd(s: S) {}
+
+@BuilderInference
+fun <S> Builder<S>.safeExtensionAdd(s: S) {}
+
+val member = build {
+    add(42)
+}
+
+val memberWithoutAnn = wrongBuild {
+    add(42)
+}
+
+val extension = build {
+    extensionAdd("foo")
+}
+
+val safeExtension = build {
+    safeExtensionAdd("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.kt

@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class Builder<T> {
+    fun add(t: T) {}
+}
+
+fun <S> build(@BuilderInference g: Builder<S>.() -> Unit): List<S> = TODO()
+fun <S> wrongBuild(g: Builder<S>.() -> Unit): List<S> = TODO()
+
+fun <S> Builder<S>.extensionAdd(s: S) {}
+
+@BuilderInference
+fun <S> Builder<S>.safeExtensionAdd(s: S) {}
+
+val member = build {
+    add(42)
+}
+
+val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>wrongBuild<!> {
+    add(42)
+}
+
+val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>build<!> {
+    extensionAdd("foo")
+}
+
+val safeExtension = build {
+    safeExtensionAdd("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.txt

@@ -0,0 +1,32 @@
+package
+
+public val extension: [ERROR : Type for build {
+    extensionAdd("foo")
+}]
+public val member: kotlin.collections.List<kotlin.Int>
+public val memberWithoutAnn: [ERROR : Type for wrongBuild {
+    add(42)
+}]
+public val safeExtension: kotlin.collections.List<kotlin.String>
+public fun </*0*/ S> build(/*0*/ @kotlin.BuilderInference g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public fun </*0*/ S> wrongBuild(/*0*/ g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public fun </*0*/ S> Builder<S>.extensionAdd(/*0*/ s: S): kotlin.Unit
+@kotlin.BuilderInference public fun </*0*/ S> Builder<S>.safeExtensionAdd(/*0*/ s: S): kotlin.Unit
+
+public final class Builder</*0*/ T> {
+    public constructor Builder</*0*/ T>()
+    public final fun add(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package kotlin {
+
+    public final annotation class BuilderInference : kotlin.Annotation {
+        public constructor BuilderInference()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.fir.kt

@@ -0,0 +1,34 @@
+// !LANGUAGE: +StableBuilderInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+}
+
+suspend fun <S> GenericController<S>.extensionYield(s: S) {}
+
+@BuilderInference
+suspend fun <S> GenericController<S>.safeExtensionYield(s: S) {}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val normal = generate {
+    yield(42)
+}
+
+val extension = generate {
+    extensionYield("foo")
+}
+
+val safeExtension = generate {
+    safeExtensionYield("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.kt

@@ -0,0 +1,33 @@
+// !LANGUAGE: +StableBuilderInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+}
+
+suspend fun <S> GenericController<S>.extensionYield(s: S) {}
+
+@BuilderInference
+suspend fun <S> GenericController<S>.safeExtensionYield(s: S) {}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val normal = generate {
+    yield(42)
+}
+
+val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    extensionYield("foo")
+}
+
+val safeExtension = generate {
+    safeExtensionYield("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtension.txt

@@ -0,0 +1,26 @@
+package
+
+public val extension: kotlin.collections.List<kotlin.String>
+public val normal: kotlin.collections.List<kotlin.Int>
+public val safeExtension: kotlin.collections.List<kotlin.String>
+public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public suspend fun </*0*/ S> GenericController<S>.extensionYield(/*0*/ s: S): kotlin.Unit
+@kotlin.BuilderInference public suspend fun </*0*/ S> GenericController<S>.safeExtensionYield(/*0*/ s: S): kotlin.Unit
+
+public final class GenericController</*0*/ T> {
+    public constructor GenericController</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public final suspend fun yield(/*0*/ t: T): kotlin.Unit
+}
+
+package kotlin {
+
+    public final annotation class BuilderInference : kotlin.Annotation {
+        public constructor BuilderInference()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.fir.kt

@@ -0,0 +1,32 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+}
+
+suspend fun <S> GenericController<S>.extensionYield(s: S) {}
+
+@BuilderInference
+suspend fun <S> GenericController<S>.safeExtensionYield(s: S) {}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val normal = generate {
+    yield(42)
+}
+
+val extension = generate {
+    extensionYield("foo")
+}
+
+val safeExtension = generate {
+    safeExtensionYield("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.kt

@@ -0,0 +1,33 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+// FILE: annotation.kt
+
+package kotlin
+
+annotation class BuilderInference
+
+// FILE: test.kt
+
+class GenericController<T> {
+    suspend fun yield(t: T) {}
+}
+
+suspend fun <S> GenericController<S>.extensionYield(s: S) {}
+
+@BuilderInference
+suspend fun <S> GenericController<S>.safeExtensionYield(s: S) {}
+
+fun <S> generate(@BuilderInference g: suspend GenericController<S>.() -> Unit): List<S> = TODO()
+
+val normal = generate {
+    yield(42)
+}
+
+val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
+    extensionYield("foo")
+}
+
+val safeExtension = generate {
+    safeExtensionYield("foo")
+}

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.txt

@@ -0,0 +1,28 @@
+package
+
+public val extension: [ERROR : Type for generate {
+    extensionYield("foo")
+}]
+public val normal: kotlin.collections.List<kotlin.Int>
+public val safeExtension: kotlin.collections.List<kotlin.String>
+public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>
+public suspend fun </*0*/ S> GenericController<S>.extensionYield(/*0*/ s: S): kotlin.Unit
+@kotlin.BuilderInference public suspend fun </*0*/ S> GenericController<S>.safeExtensionYield(/*0*/ s: S): kotlin.Unit
+
+public final class GenericController</*0*/ T> {
+    public constructor GenericController</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public final suspend fun yield(/*0*/ t: T): kotlin.Unit
+}
+
+package kotlin {
+
+    public final annotation class BuilderInference : kotlin.Annotation {
+        public constructor BuilderInference()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}