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

compiler/testData/codegen/box/callableReference/bound/genericBoundPropertyAsCrossinline.kt

@@ -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()
+}

compiler/testData/codegen/box/contracts/nestedLambdaInNonInlineCallExactlyOnce.kt

@@ -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"
+}

compiler/testData/codegen/box/coroutines/localFunctions/named/callTopLevelFromLocal.kt

@@ -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"
+}

compiler/testData/codegen/box/inlineClasses/customIterator.kt

@@ -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"
+}

compiler/testData/codegen/box/jvmStatic/extensionPropertyGetter.kt

@@ -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"
+}

compiler/testData/codegen/box/localClasses/defaultParameterInConstructor.kt

@@ -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()
+}

compiler/testData/codegen/box/objects/kt32351.kt

@@ -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"
+}

compiler/testData/codegen/box/objects/kt32749.kt

@@ -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"

compiler/testData/codegen/box/operatorConventions/kt44647.kt

@@ -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()
+}

compiler/testData/codegen/box/properties/lateinit/privateVarInCompanion.kt

@@ -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()
+}

compiler/testData/codegen/box/visibility/protectedAndPackage/kt42012.kt

@@ -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
+}