Add support for contract feature in inliner

compiler/testData/codegen/boxInline/contracts/complexInitializer.kt

@@ -0,0 +1,28 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+// FILE: 2.kt
+
+import test.*
+
+fun cond() = true
+fun test(s: String) = s
+
+fun box(): String {
+    val x: String
+    myrun {
+        x = if (cond()) test("OK") else test("fail")
+    }
+    return x
+}

compiler/testData/codegen/boxInline/contracts/complexInitializerWithStackTransformation.kt

@@ -0,0 +1,27 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+// FILE: 2.kt
+
+import test.*
+
+fun test(s: String) = s
+
+fun box(): String {
+    val x: String
+    myrun {
+        x = try { test("OK") } catch (e: Exception) { test("fail") }
+    }
+    return x
+}

compiler/testData/codegen/boxInline/contracts/definiteLongValInitialization.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+// FILE: 2.kt
+import test.*
+
+fun box(): String {
+    val x: Long
+    myrun {
+        x = 42L
+    }
+    return if (x.inc() == 43L) "OK" else "Fail: ${x.inc()}"
+}

compiler/testData/codegen/boxInline/contracts/definiteNestedValInitialization.kt

@@ -0,0 +1,27 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+
+// FILE: 2.kt
+import test.*
+
+fun box(): String {
+    val x: Int
+    myrun {
+        myrun {
+            x = 42
+        }
+    }
+    return if (x.inc() == 43) "OK" else "Fail: ${x.inc()}"
+}

compiler/testData/codegen/boxInline/contracts/definiteValInitialization.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+
+// FILE: 2.kt
+import test.*
+
+fun box(): String {
+    val x: Int
+    myrun {
+        x = 42
+    }
+    return if (x.inc() == 43) "OK" else "Fail: ${x.inc()}"
+}

compiler/testData/codegen/boxInline/contracts/nonLocalReturn.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+// FILE: 2.kt
+import test.*
+
+fun box(): String {
+    val x: Long
+    myrun {
+        x = 42L
+        if (x == 42L) return "OK"
+    }
+    return "fail"
+}

compiler/testData/codegen/boxInline/contracts/nonLocalReturnWithCycle.kt

@@ -0,0 +1,39 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// WITH_RUNTIME
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+// FILE: 2.kt
+import test.*
+
+fun test(xs: List<String>): String {
+    var result = ""
+
+    myrun L@ {
+        for (x in xs) {
+            val y: String
+            myrun {
+                y = x
+                if (y.length > 1) return@L
+            }
+            result += y
+        }
+    }
+
+    return result
+}
+
+
+fun box(): String {
+    return test(listOf("O", "K", "fail"))
+}

compiler/testData/codegen/boxInline/contracts/propertyInitialization.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+// FILE: 2.kt
+
+import test.*
+
+class A {
+    val z: String
+    init {
+        myrun {
+            z = "OK"
+        }
+    }
+}
+
+fun box(): String {
+    return A().z
+}

compiler/testData/codegen/boxInline/contracts/valInitializationAndUsageInNestedLambda.kt

@@ -0,0 +1,29 @@
+// !LANGUAGE: +CallsInPlaceEffect
+// FILE: 1.kt
+package test
+
+import kotlin.internal.contracts.*
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public inline fun <R> myrun(block: () -> R): R {
+    contract {
+        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    }
+    return block()
+}
+
+
+// FILE: 2.kt
+// NO_CHECK_LAMBDA_INLINING
+import test.*
+
+fun box(): String {
+    val x: Int
+    val res = myrun {
+        x = 42
+        {
+            x
+        }()
+    }
+    return if (res == 42 && x.inc() == 43) "OK" else "Fail: ${x.inc()}"
+}