Add tests for issues fixed in JVM IR

Note that KT-30696 is fixed only in the single-module case, and KT-42012 is not fixed fully (see KT-44855). #KT-30041 #KT-30629 #KT-30696 #KT-30933 #KT-32351 #KT-32749 #KT-38849 #KT-42012 #KT-42990 #KT-44234 #KT-44529 #KT-44631 #KT-44647
2021-02-03 15:03:30 +01:00
parent 17fc10a8af
commit 73aa465ee9
31 changed files with 826 additions and 0 deletions
@@ -0,0 +1,41 @@
+// IGNORE_BACKEND: JVM
+// DONT_TARGET_EXACT_BACKEND: WASM
+// WASM_MUTE_REASON: BINDING_RECEIVERS
+// KT-30629
+
+abstract class BaseFragment<T : BaseViewModel> {
+    lateinit var viewModel: T
+
+    open fun onActivityCreated(): String {
+        viewModel = retrieveViewModel()
+        return "Fail"
+    }
+
+    abstract fun retrieveViewModel(): T
+}
+
+class DerivedFragment : BaseFragment<DerivedViewModel>() {
+    override fun onActivityCreated(): String {
+        super.onActivityCreated()
+
+        return bind(viewModel::property)
+    }
+
+    override fun retrieveViewModel(): DerivedViewModel = DerivedViewModel()
+    inline fun <T> bind(crossinline viewModelGet: () -> T?): String {
+        return setOnFocusChangeListener { viewModelGet() as String }
+    }
+
+    fun setOnFocusChangeListener(l: () -> String): String {
+        return l()
+    }
+}
+
+abstract class BaseViewModel
+class DerivedViewModel : BaseViewModel() {
+    var property: String? = "OK"
+}
+
+fun box(): String {
+    return DerivedFragment().onActivityCreated()
+}
@@ -0,0 +1,27 @@
+// !USE_EXPERIMENTAL: kotlin.contracts.ExperimentalContracts
+// IGNORE_BACKEND: JVM
+// WITH_RUNTIME
+// KT-38849
+
+import kotlin.contracts.*
+
+fun block(lambda: () -> Unit) {
+    contract {
+        callsInPlace(lambda, InvocationKind.EXACTLY_ONCE)
+    }
+    lambda()
+}
+
+fun box(): String {
+    val list: List<Int>
+
+    block {
+        list = listOf(1, 2, 3)
+    }
+
+    block {
+        if (listOf(2, 3, 4).first { list.contains(it) } != 2) throw AssertionError("Fail")
+    }
+
+    return "OK"
+}
@@ -0,0 +1,32 @@
+// IGNORE_BACKEND: JVM
+// WITH_RUNTIME
+// WITH_COROUTINES
+// KT-30041
+
+import helpers.*
+import kotlin.coroutines.*
+
+var result = 0
+
+fun builder(block: suspend () -> Unit) {
+    block.startCoroutine(EmptyContinuation)
+}
+
+suspend fun test() {
+    suspend fun local() {
+        builder {
+            if (result++ < 1) {
+                local()
+            }
+        }
+    }
+
+    local()
+}
+
+fun box(): String {
+    builder {
+        test()
+    }
+    return if (result == 2) "OK" else "Fail: $result"
+}
@@ -0,0 +1,25 @@
+// IGNORE_BACKEND: JVM
+// DONT_TARGET_EXACT_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_TEXT
+// WITH_RUNTIME
+// KT-44529
+
+inline class InlineDouble3(val values: DoubleArray) {
+    operator fun iterator(): DoubleIterator = IteratorImpl(values)
+}
+
+// This iterator returns the first 3 elements of this.values
+private class IteratorImpl(private val values: DoubleArray) : DoubleIterator() {
+    private var index = 0
+    override fun hasNext(): Boolean = index < 3
+    override fun nextDouble(): Double = values[index++]
+}
+
+fun box(): String {
+    val values = doubleArrayOf(1.0, 2.0, 3.0, 4.0)
+    var result = ""
+    for (i in InlineDouble3(values)) {
+        result += i.toString().substring(0, 1)
+    }
+    return if (result == "123") "OK" else "Fail: $result"
+}
@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND: JVM
+// WITH_RUNTIME
+// KT-42990
+
+object O {
+    val todo: String = TODO()
+
+    fun test(): Int = Bar(todo.bar).result
+
+    val String.bar: Int
+        @JvmStatic
+        get() = 42
+}
+
+class Bar(val result: Int)
+
+fun box(): String = try {
+    O.test()
+    "Fail"
+} catch (e: NotImplementedError) {
+    "OK"
+}
@@ -0,0 +1,13 @@
+// IGNORE_BACKEND: JVM
+// KT-44631
+
+class Something(val now: String)
+
+fun box(): String {
+    val a: Something.() -> String = {
+        class MyEvent(val result: String = now)
+
+        MyEvent().result
+    }
+    return Something("OK").a()
+}
@@ -0,0 +1,27 @@
+// IGNORE_BACKEND: JVM
+// DONT_TARGET_EXACT_BACKEND: WASM
+// WASM_MUTE_REASON: UNKNOWN
+// WITH_RUNTIME
+
+interface Runnable {
+    fun run()
+}
+
+class AnonymousClassInLambda {
+    fun run(): Int {
+        var x = 0
+        val threads = (1..10).map {
+            object : Runnable {
+                override fun run() {
+                    x++
+                }
+            }
+        }
+        threads.forEach { it.run() }
+        return x
+    }
+}
+
+fun box(): String {
+    return if (AnonymousClassInLambda().run() == 10) "OK" else "Fail"
+}
@@ -0,0 +1,20 @@
+// IGNORE_BACKEND: JVM
+// WITH_RUNTIME
+
+class X {
+    val num = 42
+    val map: Int = 1.apply {
+        object : Y({ true }) {
+            override fun fun1() {
+                println(num)
+            }
+        }
+    }
+}
+
+abstract class Y(val lambda: () -> Boolean) {
+    abstract fun fun1()
+}
+
+fun box(): String =
+    if (X().map == 1) "OK" else "Fail"
@@ -0,0 +1,11 @@
+// IGNORE_BACKEND: JVM
+// IGNORE_LIGHT_ANALYSIS
+// DONT_TARGET_EXACT_BACKEND: WASM
+// WASM_MUTE_REASON: STDLIB_STRING_BUILDER
+// WITH_RUNTIME
+
+fun box(): String {
+    val sb = StringBuilder("NK")
+    sb[0]++
+    return sb.toString()
+}
@@ -0,0 +1,26 @@
+// IGNORE_BACKEND: JVM
+// KT-44234
+
+class App {
+    val context: Context = Context()
+
+    fun onCreate() {
+        instance = this
+    }
+
+    companion object {
+        private lateinit var instance: App set
+        val context: Context get() = instance.context
+    }
+
+}
+
+class Context {
+    fun print(): String = "OK"
+}
+
+fun box(): String {
+    val app = App()
+    app.onCreate()
+    return App.context.print()
+}
@@ -0,0 +1,36 @@
+// IGNORE_BACKEND: JVM
+// TARGET_BACKEND: JVM
+// MODULE: lib
+// FILE: test/Parent.java
+
+package test;
+
+public class Parent {
+    protected String qqq = "";
+
+    public String getQqq() {
+        return qqq;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.Parent
+
+open class Child : Parent() {
+    inner class QQQ {
+        fun z(x: Parent?) {
+            x as Child
+            val q = x.qqq
+            x.qqq = q + "OK"
+        }
+    }
+}
+
+fun box(): String {
+    val c = Child()
+    val d = c.QQQ()
+    d.z(c)
+    return c.qqq
+}
@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+// NO_CHECK_LAMBDA_INLINING
+// WITH_RUNTIME
+// IGNORE_BACKEND: JVM
+// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_IR, JVM_MULTI_MODULE_OLD_AGAINST_IR, JVM_MULTI_MODULE_IR_AGAINST_OLD
+// FILE: 1.kt
+
+interface Flow<T> {
+    val result: String
+}
+
+inline fun <reified T> foo() =
+    object {
+        fun test() = object : Flow<T> {
+            override val result: String = "OK"
+        }
+    }.test()
+
+// FILE: 2.kt
+
+fun box(): String =
+    foo<Any>().result
@@ -0,0 +1,21 @@
+// IGNORE_BACKEND: JVM
+// FILE: 1.kt
+
+package test
+
+class Path {
+    val events: String = "OK"
+}
+
+inline fun doSomething(path: Path): String {
+    val f = path::events
+    return f()
+}
+
+// FILE: 2.kt
+
+import test.*
+
+fun box(): String {
+    return doSomething(Path())
+}