azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update test for the builder inference and add new ones

Browse Source
This commit is contained in:
Victor Petukhov
2021-05-21 15:34:52 +03:00
parent 31ed1ad5d9
commit fd5169186e
46 changed files with 2874 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt
Vendored
+44
View File
@@ -0,0 +1,44 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// WITH_RUNTIME
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit) {}
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getInv(): Inv<R>
fun getOut(): Inv<out R>
fun getIn(): Inv<in R>
}
class Inv<T>
fun <K> captureOut(x: Inv<out K>): K = null as K
fun <K> captureIn(x: Inv<out K>): K = null as K
fun <K> capture(x: Inv<K>): K = null as K
fun box(): String {
build {
emit("")
getInv()
captureOut(getInv())
captureIn(getInv())
capture(getOut())
""
}
build {
emit("")
capture(getIn())
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt
Vendored
+59
View File
@@ -0,0 +1,59 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
// WITH_RUNTIME
// FILE: Test.java
class Test {
static <T> T foo(T x) { return x; }
}
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit) {}
class Inv<K>
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getInv(): Inv<R>
}
fun <U> id(x: U) = x
fun <E> select(vararg x: E) = x[0]
fun box(): String {
val ret = build {
emit("1")
Test.foo(get())
Test.foo(getInv())
id(get())
select(get(), get())
select(Test.foo(get()), Test.foo(get()))
select(Test.foo(get()), get())
select(getInv(), getInv())
select(Test.foo(getInv()), Test.foo(getInv()))
select(Test.foo(getInv()), getInv())
select(getInv(), Test.foo(getInv()))
select(id(get()), id(get()))
build2 {
emit(1)
select(this@build.get(), get())
select(Test.foo(this@build.get()), Test.foo(get()))
select(this@build.getInv(), getInv())
select(Test.foo(this@build.getInv()), Test.foo(getInv()))
select(Test.foo(this@build.getInv()), getInv())
select(id(this@build.get()), id(get()))
""
}
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt
Vendored
+62
View File
@@ -0,0 +1,62 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// WITH_RUNTIME
// FILE: Test.java
class Test {
static <T> T foo(T x) { return x; }
}
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
class In<in K>
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getIn(): In<R>
}
fun <U> id(x: U): U? = x
fun <E> select1(x: E, y: In<E>): E? = x
fun <E> select2(x: E, y: In<E?>): E = x
fun <E> select3(x: E?, y: In<E?>): E = x!!
fun <E> select4(x: E?, y: In<E>): E = x!!
fun box(): String {
val ret = build {
emit("1")
select1(get(), getIn())
select1(get(), Test.foo(getIn()))
select1(Test.foo(get()), Test.foo(getIn()))
select1(Test.foo(get()), getIn())
select4(get(), getIn())
select4(get(), Test.foo(getIn()))
select4(Test.foo(get()), Test.foo(getIn()))
select4(Test.foo(get()), getIn())
select4(id(Test.foo(get())), getIn())
""
}
val ret2 = build {
emit(if (true) "" else null)
select2(get(), getIn())
select2(get(), Test.foo(getIn()))
select2(Test.foo(get()), Test.foo(getIn()))
select2(Test.foo(get()), getIn())
select3(get(), getIn())
select3(get(), Test.foo(getIn()))
select3(Test.foo(get()), Test.foo(getIn()))
select3(Test.foo(get()), getIn())
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt
Vendored
+82
View File
@@ -0,0 +1,82 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
// WITH_RUNTIME
// FILE: Test.java
class Test {
static <T> T foo(T x) { return x; }
}
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
class Out<out K>
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getOut(): Out<R>
}
fun <U> id(x: U): U? = x
fun <E> select1(x: E, y: Out<E>): E? = x
fun <E> select2(x: E, y: Out<E?>): E = x
fun <E> select3(x: E?, y: Out<E?>): E = x!!
fun <E> select4(x: E?, y: Out<E>): E = x!!
fun box(): String {
val ret = build {
emit("1")
select1(get(), getOut())
select1(get(), Test.foo(getOut()))
select1(Test.foo(get()), Test.foo(getOut()))
select1(Test.foo(get()), getOut())
select2(get(), getOut())
select2(get(), Test.foo(getOut()))
select2(Test.foo(get()), Test.foo(getOut()))
select2(Test.foo(get()), getOut())
select3(get(), getOut())
select3(get(), Test.foo(getOut()))
select3(Test.foo(get()), Test.foo(getOut()))
select3(Test.foo(get()), getOut())
select4(get(), getOut())
select4(get(), Test.foo(getOut()))
select4(Test.foo(get()), Test.foo(getOut()))
select4(Test.foo(get()), getOut())
select4(id(Test.foo(get())), getOut())
build2 {
emit(1)
select1(this@build.get(), getOut())
select1(get(), Test.foo(this@build.getOut()))
select1(Test.foo(this@build.get()), Test.foo(getOut()))
select1(Test.foo(get()), this@build.getOut())
select2(this@build.get(), getOut())
select2(get(), Test.foo(this@build.getOut()))
select2(Test.foo(this@build.get()), Test.foo(getOut()))
select2(Test.foo(get()), this@build.getOut())
select3(this@build.get(), getOut())
select3(get(), Test.foo(this@build.getOut()))
select3(Test.foo(this@build.get()), Test.foo(getOut()))
select3(Test.foo(get()), this@build.getOut())
select4(this@build.get(), getOut())
select4(get(), Test.foo(this@build.getOut()))
select4(Test.foo(this@build.get()), Test.foo(getOut()))
select4(Test.foo(get()), this@build.getOut())
select4(id(Test.foo(this@build.get())), getOut())
""
}
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt
Vendored
+64
View File
@@ -0,0 +1,64 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
// WITH_RUNTIME
// FILE: Test.java
class Test {
static <T> T foo(T x) { return x; }
}
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
class Inv<K>
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getInv(): Inv<R>
}
fun <U> id(x: U): U? = x
fun <E> select1(x: E, y: Inv<E>): E? = x
fun <E> select2(x: E, y: Inv<E?>): E = x
fun <E> select3(x: E?, y: Inv<E?>): E = x!!
fun <E> select4(x: E?, y: Inv<E>): E = x!!
fun box(): String {
val ret1 = build {
emit("1")
select1(get(), getInv())
select1(get(), Test.foo(getInv()))
select1(Test.foo(get()), Test.foo(getInv()))
select1(Test.foo(get()), getInv())
select4(get(), getInv())
select4(get(), Test.foo(getInv()))
select4(Test.foo(get()), Test.foo(getInv()))
select4(Test.foo(get()), getInv())
select4(id(Test.foo(get())), getInv())
""
}
val ret2 = build {
emit(if (true) "1" else null)
select2(get(), getInv())
select2(get(), Test.foo(getInv()))
select2(Test.foo(get()), Test.foo(getInv()))
select2(Test.foo(get()), getInv())
select3(get(), getInv())
select3(get(), Test.foo(getInv()))
select3(Test.foo(get()), Test.foo(getInv()))
select3(Test.foo(get()), getInv())
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt
Vendored
+83
View File
@@ -0,0 +1,83 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
// WITH_RUNTIME
// FILE: Test.java
import org.jetbrains.annotations.*;
class Test {
@Nullable
static <T> T foo(T x) { return x; }
}
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build2(@BuilderInference block: TestInterface<R>.() -> Unit) {}
class Inv<K>
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getInv(): Inv<R>
}
fun <U> id(x: U): U? = x
fun <E> select(vararg x: E): E? = x[0]
fun box(): String {
val ret = build {
emit("1")
Test.foo(get())
Test.foo(getInv())
id(get())
select(get(), get())
select(Test.foo(get()), Test.foo(get()))
select(Test.foo(get()), get())
select(getInv(), getInv())
select(Test.foo(getInv()), Test.foo(getInv()))
select(Test.foo(getInv()), getInv())
select(getInv(), Test.foo(getInv()))
select(id(get()), id(get()))
build2 {
emit(1)
select(this@build.get(), get())
select(Test.foo(this@build.get()), Test.foo(get()))
select(this@build.getInv(), getInv())
select(Test.foo(this@build.getInv()), Test.foo(getInv()))
select(Test.foo(this@build.getInv()), getInv())
select(id(this@build.get()), id(get()))
""
}
""
}
val ret2 = build {
emit("1")
select(get(), null)
select(Test.foo(null), Test.foo(get()))
select(Test.foo(get()), null)
select(null, getInv())
select(Test.foo(getInv()), Test.foo(null))
select(Test.foo(null), getInv())
select(getInv(), Test.foo(null))
select(id(null), id(get()))
build2 {
emit(1)
select(this@build.get(), get(), null)
select(Test.foo(this@build.get()), Test.foo(get()), null)
select(this@build.getInv(), getInv(), null)
select(Test.foo(this@build.getInv()), Test.foo(getInv()), null)
select(Test.foo(this@build.getInv()), getInv(), null)
select(id(this@build.get()), id(get()), null)
""
}
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/intersect.kt
Vendored
+49
View File
@@ -0,0 +1,49 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// WITH_RUNTIME
// FILE: Test.java
class Test {
static <T> T foo(T x) { return x; }
}
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R2> build2(@BuilderInference block: TestInterface<R2>.() -> Unit) {}
class In<in K>
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
fun getIn(): In<R>
}
fun <U> id(x: U) = x
fun <E> intersect(vararg x: In<E>): E = null as E
fun box(): String {
val ret = build {
emit("1")
intersect(getIn(), getIn())
intersect(getIn(), Test.foo(getIn()))
intersect(Test.foo(getIn()), Test.foo(getIn()))
intersect(Test.foo(getIn()), getIn())
build2 {
emit(1)
intersect(this@build.getIn(), getIn())
intersect(getIn(), Test.foo(this@build.getIn()))
intersect(Test.foo(this@build.getIn()), Test.foo(getIn()))
intersect(Test.foo(getIn()), this@build.getIn())
""
}
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/labaledCall.kt
Vendored
+23
View File
@@ -0,0 +1,23 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -UNCHECKED_CAST -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
// WITH_RUNTIME
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
@UseExperimental(ExperimentalTypeInference::class)
fun <R> build(@BuilderInference block: TestInterface<R>.() -> Unit) {}
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
}
fun box(): String {
build myLabel@ {
emit("")
val x = this@myLabel
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/memberScope.kt
Vendored
+72
View File
@@ -0,0 +1,72 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
// WITH_RUNTIME
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
}
@UseExperimental(ExperimentalTypeInference::class)
fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
fun Any.test() {}
fun Any?.test2() {}
fun box(): String {
val ret = build {
emit(1)
emit(null)
get()?.test()
get()?.test2()
get().test2()
get()?.hashCode()
get()?.equals(1)
val x = get()
x?.hashCode()
x?.equals(1)
if (get() == null) {}
if (get() === null) {}
if (x != null) {
x?.hashCode()
x?.equals(1)
x.equals("")
x.hashCode()
x.toString()
x.test()
x?.test2()
x.test2()
}
if (x == null) {
x?.hashCode()
x?.equals(1)
// x.equals("") // it'd be an error, because here we try to add constraint `Nothing? < Any`
// x.hashCode()
// x.toString()
// x.test()
x?.test2()
x.test2()
}
if (x === null) {
x?.hashCode()
x?.equals(1)
// x.equals("") // it'd be an error, because here we try to add constraint `Nothing? < Any`
// x.hashCode()
// x.toString()
// x.test()
x?.test2()
x.test2()
}
""
}
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/nullability.kt
Vendored
+67
View File
@@ -0,0 +1,67 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
// WITH_RUNTIME
// FILE: main.kt
import kotlin.experimental.ExperimentalTypeInference
interface TestInterface<R> {
fun emit(r: R)
fun get(): R
}
@UseExperimental(ExperimentalTypeInference::class)
fun <R1> build(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R1 : Any> build2(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R1 : R2, R2 : Any> build3(@BuilderInference block: TestInterface<R1>.() -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <R1 : R2, R2> build4(x: R2, @BuilderInference block: TestInterface<R1>.() -> Unit) {}
fun test(a: String?) {
val ret1 = build {
emit(1)
get()?.equals("")
val x = get()
x?.equals("")
x ?: 1
x!!
""
}
val ret2 = build2 {
emit(1)
get()?.equals("")
val x = get()
x?.equals("")
x ?: 1
x!!
""
}
val ret3 = build3 {
emit(1)
get()?.equals("")
val x = get()
x?.equals("")
x ?: 1
x!!
""
}
val ret4 = build4(1) {
emit(1)
get()?.equals("")
val x = get()
x?.equals("")
x ?: 1
x!!
""
}
}
fun box(): String {
test("")
return "OK"
}
compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt
Vendored
+171
View File
@@ -0,0 +1,171 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// WITH_RUNTIME
// SKIP_TXT
import kotlin.experimental.ExperimentalTypeInference
fun <K> FlowCollector<K>.bar(): K = null as K
fun <K> FlowCollector<K>.foo(): K = null as K
fun <K> K.bar3(): K = null as K
fun <K> K.foo3(): K = null as K
fun bar2(): Int = 1
fun foo2(): Float = 1f
val bar4: Int
get() = 1
var foo4: Float
get() = 1f
set(value) {}
val <K> FlowCollector<K>.bar5: K get() = null as K
val <K> FlowCollector<K>.foo5: K get() = null as K
class Foo6
class Foo7<T>
fun foo7() = null as Foo7<Int>
interface FlowCollector<in T> {}
@OptIn(ExperimentalTypeInference::class)
fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
fun poll1(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar2 } else { ::foo2 }
inv()
}
}
fun poll11(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar2 } else { ::foo2 }
inv()
}
}
fun poll12(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar3 } else { ::foo3 }
inv()
}
}
fun poll13(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar2 } else { ::foo3 }
inv()
}
}
fun poll14(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar4 } else { ::foo4 }
inv()
}
}
fun poll15(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar5 } else { ::foo5 }
inv()
}
}
fun poll16(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::Foo6 } else { ::Foo6 }
inv()
}
}
fun poll4(): Flow<String> {
return flow {
val inv = try { ::bar } finally { ::foo }
inv()
}
}
fun poll41(): Flow<String> {
return flow {
val inv = try { ::bar2 } finally { ::foo2 }
inv()
}
}
fun poll42(): Flow<String> {
return flow {
val inv = try { ::bar3 } finally { ::foo3 }
inv()
}
}
fun poll43(): Flow<String> {
return flow {
val inv = try { ::bar4 } finally { ::foo4 }
inv()
}
}
fun poll44(): Flow<String> {
return flow {
val inv = try { ::bar5 } finally { ::foo5 }
inv()
}
}
fun poll45(): Flow<String> {
return flow {
val inv = try { ::Foo6 } finally { ::Foo6 }
inv()
}
}
fun poll5(): Flow<String> {
return flow {
val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
inv()
}
}
fun poll51(): Flow<String> {
return flow {
val inv = try { ::bar2 } catch (e: Exception) { ::foo2 } finally { ::foo2 }
inv()
}
}
fun poll52(): Flow<String> {
return flow {
val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::foo3 }
inv()
}
}
fun poll53(): Flow<String> {
return flow {
val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 }
inv()
}
}
fun poll54(): Flow<String> {
return flow {
val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
inv()
}
}
fun poll55(): Flow<String> {
return flow {
val inv = try { ::Foo6 } catch (e: Exception) { ::Foo6 } finally { ::Foo6 }
inv()
}
}
fun box() = "OK"
compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt
Vendored
+66
View File
@@ -0,0 +1,66 @@
// WITH_RUNTIME
// SKIP_TXT
// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
import kotlin.experimental.ExperimentalTypeInference
fun <K> FlowCollector<K>.bar(): K = null as K
fun <K> FlowCollector<K>.foo(): K = null as K
fun <K> K.bar3(): K = null as K
fun <K> K.foo3(): K = null as K
fun bar2(): Int = 1
fun foo2(): Float = 1f
val bar4: Int
get() = 1
var foo4: Float
get() = 1f
set(value) {}
val <K> FlowCollector<K>.bar5: K get() = null as K
val <K> FlowCollector<K>.foo5: K get() = null as K
class Foo6
class Foo7<T>
fun foo7() = null as Foo7<Int>
interface FlowCollector<in T> {}
@OptIn(ExperimentalTypeInference::class)
fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)
class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
fun poll71(): Flow<String> {
return flow {
val inv = ::bar2!!
inv()
}
}
fun poll73(): Flow<String> {
return flow {
val inv = ::bar4!!
inv
}
}
fun poll75(): Flow<String> {
return flow {
val inv = ::Foo6!!
inv
}
}
fun poll85(): Flow<String> {
return flow {
val inv = ::Foo6 in setOf(::Foo6)
inv
}
}
fun box() = "OK"
compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt
Vendored
+80
View File
@@ -0,0 +1,80 @@
// !LANGUAGE: +UnrestrictedBuilderInference
// WITH_RUNTIME
// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -CAST_NEVER_SUCCEEDS
import kotlin.experimental.ExperimentalTypeInference
fun <K> id(x: K): K = x
@UseExperimental(ExperimentalTypeInference::class)
fun <K, V> build(@BuilderInference builderAction: MutableMap<K, V>.() -> V) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <K, V> build2(@BuilderInference builderAction: MutableMap<K, V>.() -> K) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <K, V> build3(@BuilderInference builderAction: MutableMap<K, V>.(K) -> Unit) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <K, V> build4(@BuilderInference builderAction: MutableMap<K, V>.() -> MutableMap<String, Int>) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <K : V, V : CharSequence> build5(@BuilderInference builderAction: MutableMap<K, V>.() -> MutableMap<String, V>) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <K : V, V : CharSequence> build6(@BuilderInference builderAction: MutableMap<K, V>.() -> MutableMap<K, String>) {}
@UseExperimental(ExperimentalTypeInference::class)
fun <K : V, V : CharSequence> build7(@BuilderInference builderAction: MutableMap<K, V>.() -> MutableMap<String, V>) = mutableMapOf<String, V>()
@ExperimentalStdlibApi
fun box(): String {
buildList {
add("")
val x: MutableList<CharSequence> = this@buildList
}
buildMap {
val x: Function2<String, Char, Char?> = ::put
}
build {
get("")
""
}
build2 {
val x: String = this.values.first()
1
}
build2 {
take(this.values.first())
1
}
build3 { key: String ->
take(this.values.first())
}
build3 { this.foo() }
build4 { this }
build4 { this.run { this } }
build4 { run { this } }
build4 { id(run { this }) }
build5 { id(run { this }) }
build6 { id(run { this }) }
val x: MutableMap<String, CharSequence> = build7 {
id(run { this })
}
return "OK"
}
fun MutableMap<String, Int>.foo() {}
fun take(x: String) {}