Move JVM8 box test to common

compiler/testData/codegen/box/annotations/useTypeParameterAnnotationFromJava.kt

@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// FULL_JDK
+// JVM_TARGET: 1.8
+// FILE: A.java
+import java.util.List;
+
+public class A<@Anno(1) T> {}
+
+// FILE: Anno.kt
+
+import kotlin.test.assertEquals
+
+@Target(AnnotationTarget.TYPE_PARAMETER)
+annotation class Anno(val value: Int = 0)
+
+fun box(): String {
+    val typeParameter = A::class.java.typeParameters.single()
+    assertEquals("[@Anno(value=1)]", typeParameter.annotations.toList().toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/annotations/useTypeUseAnnotationFromJava.kt

@@ -0,0 +1,30 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// FULL_JDK
+// JVM_TARGET: 1.8
+// FILE: A.java
+import java.util.List;
+
+public class A {
+    public static @Anno(1) String test(List<@Anno(2) String> list) {
+        return list.get(0);
+    }
+}
+
+// FILE: Anno.kt
+
+import java.lang.reflect.AnnotatedParameterizedType
+import kotlin.test.assertEquals
+
+@Target(AnnotationTarget.TYPE)
+annotation class Anno(val value: Int = 0)
+
+fun box(): String {
+    val method = A::class.java.declaredMethods.single()
+    assertEquals("[@Anno(value=1)]", method.annotatedReturnType.annotations.toList().toString())
+
+    val parameterType = method.parameters.single().annotatedType as AnnotatedParameterizedType
+    assertEquals("[@Anno(value=2)]", parameterType.annotatedActualTypeArguments.single().annotations.toList().toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/immutableRemove.kt

@@ -0,0 +1,52 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+interface ImmutableCollection<out E> : Collection<E> {
+    fun add(element: @UnsafeVariance E): ImmutableCollection<E>
+    fun addAll(elements: Collection<@UnsafeVariance E>): ImmutableCollection<E>
+    fun remove(element: @UnsafeVariance E): ImmutableCollection<E>
+}
+
+class ImmutableCollectionmpl<E> : ImmutableCollection<E> {
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun contains(element: E): Boolean {
+        throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun containsAll(elements: Collection<E>): Boolean {
+        throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun iterator(): Iterator<E> {
+        throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
+
+    override fun add(element: E): ImmutableCollection<E> = this
+    override fun addAll(elements: Collection<E>): ImmutableCollection<E> = this
+    override fun remove(element: E): ImmutableCollection<E> = this
+}
+
+fun box(): String {
+    val c = ImmutableCollectionmpl<String>()
+    if (c.remove("") !== c) return "fail 1"
+    if (c.add("") !== c) return "fail 2"
+    if (c.addAll(java.util.ArrayList()) !== c) return "fail 3"
+
+    val method = c.javaClass.methods.single { it.name == "remove" && it.returnType == Boolean::class.javaPrimitiveType }
+
+    try {
+        method.invoke(c, "")
+        return "fail 4"
+    } catch (e: java.lang.reflect.InvocationTargetException) {
+        if (e.cause!!.message != "Operation is not supported for read-only collection") return "fail 5: ${e.cause!!.message}"
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault/noTypeSafeBridge.kt

@@ -0,0 +1,67 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+class A : MutableMap<Any, Any?> {
+    override val entries: MutableSet<MutableMap.MutableEntry<Any, Any?>>
+        get() = throw UnsupportedOperationException()
+    override val keys: MutableSet<Any>
+        get() = throw UnsupportedOperationException()
+    override val values: MutableCollection<Any?>
+        get() = throw UnsupportedOperationException()
+
+    override fun clear() {
+        throw UnsupportedOperationException()
+    }
+
+    override fun put(key: Any, value: Any?): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun putAll(from: Map<out Any, Any?>) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun containsKey(key: Any): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun containsValue(value: Any?): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun get(key: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getOrDefault(key: Any, defaultValue: Any?): Any? {
+        if (key == "abc") return "cde"
+        return defaultValue
+    }
+}
+
+fun box(): String {
+    val a = A()
+    if (a.getOrDefault("abc", "xyz") != "cde") return "fail 1"
+    if (a.getOrDefault("56", "123") != "123") return "fail 2"
+
+    val mm = a as MutableMap<Any?, Any?>
+    if (mm.getOrDefault("abc", "xyz") != "cde") return "fail 3"
+    if (mm.getOrDefault("56", 123) != 123) return "fail 4"
+    if (mm.getOrDefault(1, "456") != "456") return "fail 5"
+    if (mm.getOrDefault(null, "qwe") != "qwe") return "fail 6"
+    if (mm.getOrDefault("abc", null) != "cde") return "fail 7"
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault/typeSafeBridge.kt

@@ -0,0 +1,75 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+class A : MutableMap<String, String> {
+    override val entries: MutableSet<MutableMap.MutableEntry<String, String>>
+        get() = throw UnsupportedOperationException()
+    override val keys: MutableSet<String>
+        get() = throw UnsupportedOperationException()
+    override val values: MutableCollection<String>
+        get() = throw UnsupportedOperationException()
+
+    override fun clear() {
+        throw UnsupportedOperationException()
+    }
+
+    override fun put(key: String, value: String): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun putAll(from: Map<out String, String>) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: String): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun containsKey(key: String): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun containsValue(value: String): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun get(key: String): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getOrDefault(key: String, defaultValue: String): String {
+        if (key == "abc") return "cde"
+        return defaultValue
+    }
+}
+
+fun box(): String {
+    val a = A()
+    if (a.getOrDefault("abc", "xyz") != "cde") return "fail 1"
+    if (a.getOrDefault("56", "123") != "123") return "fail 2"
+
+    val mm = a as MutableMap<Any?, Any?>
+    if (mm.getOrDefault("abc", "xyz") != "cde") return "fail 3"
+    if (mm.getOrDefault("56", "123") != "123") return "fail 4"
+    if (mm.getOrDefault(1, "456") != "456") return "fail 5"
+    if (mm.getOrDefault(null, "qwe") != "qwe") return "fail 6"
+
+    try {
+        // This is a known problem, there's no way to implement type-safe bridge/barrier properly:
+        // 'override fun getOrDefault(key: String, defaultValue: String): String' expects two strings,
+        // and returning defaultValue if Int was received seems incorrect here
+        mm.getOrDefault("abc", 123)
+        return "fail 7"
+    } catch (e: java.lang.ClassCastException) {
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault/typeSafeBridgeNotNullAny.kt

@@ -0,0 +1,81 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+class A : MutableMap<Any, Any> {
+    override val entries: MutableSet<MutableMap.MutableEntry<Any, Any>>
+        get() = throw UnsupportedOperationException()
+    override val keys: MutableSet<Any>
+        get() = throw UnsupportedOperationException()
+    override val values: MutableCollection<Any>
+        get() = throw UnsupportedOperationException()
+
+    override fun clear() {
+        throw UnsupportedOperationException()
+    }
+
+    override fun put(key: Any, value: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun putAll(from: Map<out Any, Any>) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun containsKey(key: Any): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun containsValue(value: Any): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun get(key: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getOrDefault(key: Any, defaultValue: Any): Any {
+        // this condition can not be true because of checkParameterIsNotNull checks in the begin of every method, but it's left here
+        // to emphasize that we expect these parameters are not null
+        if (key == null || defaultValue == null) {
+            throw IllegalArgumentException("fail")
+        }
+        if (key == "abc") return "cde"
+        return defaultValue
+    }
+}
+
+fun box(): String {
+    val a = A()
+    if (a.getOrDefault("abc", "xyz") != "cde") return "fail 1"
+    if (a.getOrDefault("56", "123") != "123") return "fail 2"
+
+    val mm = a as MutableMap<Any?, Any?>
+    if (mm.getOrDefault("abc", "xyz") != "cde") return "fail 3"
+    if (mm.getOrDefault("56", 123) != 123) return "fail 4"
+    if (mm.getOrDefault(1, "456") != "456") return "fail 5"
+    if (mm.getOrDefault(null, "qwe") != "qwe") return "fail 6"
+
+    try {
+        // This is a known problem, there's no way to implement type-safe bridge/barrier properly:
+        // 'override fun getOrDefault(key: Any, defaultValue: Any): Any' expects two not-nullable values,
+        // and returning defaultValue if null was received seems incorrect here
+        mm.getOrDefault("abc", null)
+        return "fail 7"
+    } catch (e: java.lang.IllegalArgumentException) {
+        // Parameter specified as non-null is null
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapRemove/noDefaultImpls.kt

@@ -0,0 +1,34 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+// There should be no DefaultImpls method for MutableMap.remove(K;V)
+interface A<K, V> : MutableMap<K, V>
+
+class B : A<String, String>, java.util.AbstractMap<String, String>() {
+    override val entries: MutableSet<MutableMap.MutableEntry<String, String>>
+        get() = java.util.HashSet()
+}
+
+interface C<K, V> : MutableMap<K, V> {
+    @JvmDefault
+    override fun remove(key: K, value: V) = true
+}
+
+class D : A<String, String>, java.util.AbstractMap<String, String>() {
+    override val entries: MutableSet<MutableMap.MutableEntry<String, String>>
+        get() = java.util.HashSet()
+}
+
+fun box(): String {
+    val x1 = B().remove("1", "2")
+    if (x1) return "fail 1"
+
+    val x2 = D().remove("3", "4")
+    if (x1) return "fail 2"
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapRemove/readOnlyMap.kt

@@ -0,0 +1,46 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+// FILE: A.java
+public class A {
+    public static void foo(java.util.Map<String, String> x) {
+        x.remove("abc", "cde");
+    }
+}
+
+// FILE: main.kt
+
+class ReadOnlyMap<K, V>(val x: K, val y: V) : Map<K, V> {
+    override val entries: Set<Map.Entry<K, V>>
+        get() = throw UnsupportedOperationException()
+    override val keys: Set<K>
+        get() = throw UnsupportedOperationException()
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+    override val values: Collection<V>
+        get() = throw UnsupportedOperationException()
+
+    override fun containsKey(key: K) = key == x
+
+    override fun containsValue(value: V) = value == y
+
+    override fun get(key: K): V? = if (key == x) y else null
+
+    override fun isEmpty() = false
+}
+
+fun box(): String {
+    try {
+        A.foo(ReadOnlyMap("abc", "cde"))
+        return "fail 1"
+    } catch (e: UnsupportedOperationException) { }
+
+    try {
+        // Default Map 'remove' implenetation actually does remove iff entry exists
+        A.foo(ReadOnlyMap("abc", "123"))
+        return "fail 2"
+    } catch (e: UnsupportedOperationException) { }
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapRemove/typeSafeBridge.kt

@@ -0,0 +1,69 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+class A : MutableMap<String, String> {
+    override val entries: MutableSet<MutableMap.MutableEntry<String, String>>
+        get() = throw UnsupportedOperationException()
+    override val keys: MutableSet<String>
+        get() = throw UnsupportedOperationException()
+    override val values: MutableCollection<String>
+        get() = throw UnsupportedOperationException()
+
+    override fun clear() {
+        throw UnsupportedOperationException()
+    }
+
+    override fun put(key: String, value: String): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun putAll(from: Map<out String, String>) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: String): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun containsKey(key: String): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun containsValue(value: String): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun get(key: String): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: String, value: String): Boolean {
+        val h = key.hashCode() + value.hashCode()
+        if (h != ("abc".hashCode() + "cde".hashCode())) return false
+        return key == "abc" && value == "cde"
+    }
+}
+
+fun box(): String {
+    val a = A()
+    if (!a.remove("abc", "cde")) return "fail 1"
+    if (a.remove("abc", "123")) return "fail 2"
+
+    val mm = a as MutableMap<Any?, Any?>
+    if (!mm.remove("abc", "cde")) return "fail 3"
+    if (mm.remove("abc", "123")) return "fail 4"
+    if (mm.remove(1, "cde")) return "fail 5"
+    if (mm.remove(null, "cde")) return "fail 6"
+    if (mm.remove("abc", null)) return "fail 7"
+    if (mm.remove(null, null)) return "fail 8"
+
+    return "OK"
+}

compiler/testData/codegen/box/builtinStubMethods/mapRemove/typeSafeBridgeNotNullAny.kt

@@ -0,0 +1,69 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+class A : MutableMap<Any, Any> {
+    override val entries: MutableSet<MutableMap.MutableEntry<Any, Any>>
+        get() = throw UnsupportedOperationException()
+    override val keys: MutableSet<Any>
+        get() = throw UnsupportedOperationException()
+    override val values: MutableCollection<Any>
+        get() = throw UnsupportedOperationException()
+
+    override fun clear() {
+        throw UnsupportedOperationException()
+    }
+
+    override fun put(key: Any, value: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun putAll(from: Map<out Any, Any>) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun containsKey(key: Any): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun containsValue(value: Any): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun get(key: Any): Any? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun remove(key: Any, value: Any): Boolean {
+        val h = key.hashCode() + value.hashCode()
+        if (h != ("abc".hashCode() + "cde".hashCode())) return false
+        return key == "abc" && value == "cde"
+    }
+}
+
+fun box(): String {
+    val a = A()
+    if (!a.remove("abc", "cde")) return "fail 1"
+    if (a.remove("abc", "123")) return "fail 2"
+
+    val mm = a as MutableMap<Any?, Any?>
+    if (!mm.remove("abc", "cde")) return "fail 3"
+    if (mm.remove("abc", "123")) return "fail 4"
+    if (mm.remove(1, "cde")) return "fail 5"
+    if (mm.remove(null, "cde")) return "fail 6"
+    if (mm.remove("abc", null)) return "fail 7"
+    if (mm.remove(null, null)) return "fail 8"
+
+    return "OK"
+}

compiler/testData/codegen/box/coroutines/async.kt

@@ -0,0 +1,75 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// COMMON_COROUTINES_TEST
+// FULL_JDK
+// WITH_COROUTINES
+
+import java.util.concurrent.CompletableFuture
+import COROUTINES_PACKAGE.*
+import COROUTINES_PACKAGE.intrinsics.*
+
+fun foo(): CompletableFuture<String> = CompletableFuture.supplyAsync { "foo" }
+fun bar(v: String): CompletableFuture<String> = CompletableFuture.supplyAsync { "bar with $v" }
+fun exception(v: String): CompletableFuture<String> = CompletableFuture.supplyAsync { throw RuntimeException(v) }
+
+fun foobar(x: String, y: String) = x + y
+
+fun box(): String {
+    var result = ""
+    fun log(x: String) {
+        if (result.isNotEmpty()) result += "\n"
+        result += x
+    }
+
+    val future = async<String> {
+        log("start")
+        val x = await(foo())
+        log("got '$x'")
+        val y = foobar("123 ", await(bar(x)))
+        log("got '$y' after '$x'")
+        y
+    }
+
+    future.whenComplete { value, t ->
+        log("completed with '$value'")
+    }.join()
+
+    val expectedResult =
+    """
+    |start
+    |got 'foo'
+    |got '123 bar with foo' after 'foo'
+    |completed with '123 bar with foo'""".trimMargin().trim('\n', ' ')
+
+    if (expectedResult != result) return result
+
+    return "OK"
+}
+
+// LIBRARY CODE
+
+fun <T> async(c: suspend () -> T): CompletableFuture<T> {
+    val future = CompletableFuture<T>()
+    c.startCoroutine(object : helpers.ContinuationAdapter<T>() {
+        override val context = EmptyCoroutineContext
+
+        override fun resume(data: T) {
+            future.complete(data)
+        }
+
+        override fun resumeWithException(exception: Throwable) {
+            future.completeExceptionally(exception)
+        }
+    })
+    return future
+}
+
+suspend fun <V> await(f: CompletableFuture<V>) = suspendCoroutineUninterceptedOrReturn<V> { machine ->
+    f.whenComplete { value, throwable ->
+        if (throwable == null)
+            machine.resume(value)
+        else
+            machine.resumeWithException(throwable)
+    }
+    COROUTINE_SUSPENDED
+}

compiler/testData/codegen/box/coroutines/asyncException.kt

@@ -0,0 +1,72 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// COMMON_COROUTINES_TEST
+// FULL_JDK
+// WITH_COROUTINES
+
+import java.util.concurrent.CompletableFuture
+import COROUTINES_PACKAGE.*
+import COROUTINES_PACKAGE.intrinsics.*
+
+fun exception(v: String): CompletableFuture<String> = CompletableFuture.supplyAsync { throw RuntimeException(v) }
+
+fun foobar(x: String, y: String) = x + y
+
+fun box(): String {
+    var result = ""
+
+    val future = async<String>() {
+        try {
+            await(exception("OK"))
+        } catch (e: Exception) {
+            result = e.cause?.message!!
+        }
+        "56"
+    }
+
+    future.join()
+
+    if (future.get() != "56") return "fail: ${future.get()}"
+
+    if (result != "OK") return "fail notOk"
+
+    val future2 = async<String>() {
+        await(exception("OK"))
+        "fail"
+    }
+
+    try {
+        future2.get()
+    } catch (e: Exception) {
+        if (e.cause!!.message != "OK") return "fail message: ${e.cause!!.message}"
+        return "OK"
+    }
+
+    return "No exception"
+}
+
+fun <T> async(c: suspend () -> T): CompletableFuture<T> {
+    val future = CompletableFuture<T>()
+    c.startCoroutine(object : helpers.ContinuationAdapter<T>() {
+        override val context = EmptyCoroutineContext
+
+        override fun resume(data: T) {
+            future.complete(data)
+        }
+
+        override fun resumeWithException(exception: Throwable) {
+            future.completeExceptionally(exception)
+        }
+    })
+    return future
+}
+
+suspend fun <V> await(f: CompletableFuture<V>) = suspendCoroutineUninterceptedOrReturn<V> { machine ->
+    f.whenComplete { value, throwable ->
+        if (throwable == null)
+            machine.resume(value)
+        else
+            machine.resumeWithException(throwable)
+    }
+    COROUTINE_SUSPENDED
+}

compiler/testData/codegen/box/delegation/byMiddleInterface.kt

@@ -0,0 +1,28 @@
+// TARGET_BACKEND: JVM
+
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: main.kt
+
+public interface BaseKotlin : Base {
+}
+
+
+class Fail : BaseKotlin {
+    override fun getValue() = "Fail"
+}
+
+fun box(): String {
+    val z = object : BaseKotlin by Fail() {
+        override fun getValue() = "OK"
+    }
+    return z.test()
+}

compiler/testData/codegen/box/delegation/defaultOverride.kt

@@ -0,0 +1,32 @@
+// TARGET_BACKEND: JVM
+
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: main.kt
+
+public interface BaseKotlin : Base {
+    override fun getValue() = "OK"
+
+    override fun test(): String {
+        return getValue();
+    }
+}
+
+class OK : BaseKotlin {
+    override fun getValue() = "OK"
+}
+
+fun box(): String {
+    val ok = object : BaseKotlin by OK() {
+        override fun getValue() = "Fail"
+    }
+    return ok.test()
+}

compiler/testData/codegen/box/delegation/delegationToMap.kt

@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+
+class MapWithBadDefaults : HashMap<String, String>() {
+    override fun getOrDefault(key: String, defaultValue: String): String {
+        throw RuntimeException("Shouldn't be executed")
+    }
+
+    override fun remove(key: String, value: String): Boolean {
+        throw RuntimeException("Shouldn't be executed")
+    }
+}
+
+
+class Test(map: MutableMap<String, String>) : MutableMap<String, String> by map
+
+fun box(): String {
+    val test = Test(MapWithBadDefaults())
+    test.put("O", "K")
+    if (!test.containsKey("O")) return "fail 1: can't find value for key 'O'"
+    if (!test.remove("O", "K")) return "fail 2: entry wasn't removed"
+
+    return test.getOrDefault("absent", "OK")
+}

compiler/testData/codegen/box/delegation/diamond.kt

@@ -0,0 +1,36 @@
+// TARGET_BACKEND: JVM
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: Base2.java
+public interface Base2 extends Base {
+
+    default String test() {
+        return "O"  + getValue();
+    }
+}
+
+
+// FILE: main.kt
+
+interface KBase : Base
+
+interface Derived : KBase, Base2
+
+class Fail : Derived {
+    override fun getValue() = "Fail"
+}
+
+fun box(): String {
+    val z = object : Derived by Fail() {
+        override fun getValue() = "K"
+    }
+    return z.test()
+}

compiler/testData/codegen/box/delegation/diamond2.kt

@@ -0,0 +1,36 @@
+// TARGET_BACKEND: JVM
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test()
+    {
+        return getValue();
+    }
+}
+
+// FILE: Base2.java
+public interface Base2 extends Base {
+
+}
+
+
+// FILE: main.kt
+
+interface KBase : Base {
+    override fun test() = "O" + getValue()
+}
+
+interface Derived : KBase, Base2
+
+class K : Derived {
+    override fun getValue() = "K"
+}
+
+fun box(): String {
+    val z = object : Derived by K() {
+        override fun getValue() = "Fail"
+    }
+    return z.test()
+}

compiler/testData/codegen/box/delegation/inClassDeclaration.kt

@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: main.kt
+class Fail : Base {
+    override fun getValue() = "Fail"
+}
+
+class Derived : Base by Fail() {
+    override fun getValue() = "OK"
+}
+
+fun box(): String {
+    return Derived().test()
+}

compiler/testData/codegen/box/delegation/mixed.kt

@@ -0,0 +1,33 @@
+// TARGET_BACKEND: JVM
+// FILE: Base.java
+
+public interface Base extends KBase {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: main.kt
+interface KBase {
+    fun getValue(): String
+
+    fun test(): String
+}
+
+class Fail : Base {
+    override fun getValue() = "Fail"
+}
+
+fun box(): String {
+    val z1 = object : KBase by Fail() {
+        override fun getValue() = "OK"
+    }
+    if (z1.test() != "Fail") return "fail 1"
+
+    val z2 = object : Base by Fail() {
+        override fun getValue() = "OK"
+    }
+    return z2.test()
+}

compiler/testData/codegen/box/delegation/simple.kt

@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: main.kt
+class Fail : Base {
+    override fun getValue() = "Fail"
+}
+
+fun box(): String {
+    val z = object : Base by Fail() {
+        override fun getValue() = "OK"
+    }
+    return z.test()
+}

compiler/testData/codegen/box/delegation/simple1.0.kt

@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// LANGUAGE_VERSION: 1.0
+// FILE: Base.java
+
+public interface Base {
+    String getValue();
+
+    default String test() {
+        return getValue();
+    }
+}
+
+// FILE: main.kt
+class OK : Base {
+    override fun getValue() = "OK"
+}
+
+fun box(): String {
+    val z = object : Base by OK() {
+        override fun getValue() = "Fail"
+    }
+    return z.test()
+}

compiler/testData/codegen/box/javaInterop/notNullAssertions/functionAssertion.kt

@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+// FILE: F.java
+import java.util.function.Function;
+
+public class F {
+    public static <T, U> U passNull(Function<? super T, ? extends U> f) {
+        return f.apply(null);
+    }
+}
+
+// FILE: test.kt
+// WITH_RUNTIME
+// FULL_JDK
+fun test(f: (Int?) -> String): String {
+    return F.passNull(f)
+}
+
+fun box(): String {
+    return test {
+        it?.toString() ?: "OK"
+    }
+}

compiler/testData/codegen/box/jdk/removeIf.kt

@@ -0,0 +1,34 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+
+import java.util.*
+import java.util.function.Predicate
+
+class MyList : AbstractCollection<String>(), MutableCollection<String> {
+    override fun iterator(): MutableIterator<String> {
+        throw UnsupportedOperationException()
+    }
+
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun removeIf(predicate: Predicate<in String>) =
+            predicate.test("abc")
+}
+
+fun box(): String {
+    val ml = mutableListOf("xyz", "abc")
+
+    if (!ml.removeIf { x -> x == "abc" }) return "fail 1"
+    if (ml.removeIf { x -> x == "abc" }) return "fail 2"
+
+    if (ml != listOf("xyz")) return "fail 3"
+
+    val myList = MyList()
+
+    if (!myList.removeIf { x -> x == "abc" }) return "fail 4"
+    if (myList.removeIf { x -> x == "xyz" }) return "fail 5"
+
+    return "OK"
+}

compiler/testData/codegen/box/jdk/stream.kt

@@ -0,0 +1,63 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_RUNTIME
+// LANGUAGE_VERSION: 1.1
+import java.util.stream.*
+
+class B<F> : List<F> {
+    override val size: Int
+        get() = throw UnsupportedOperationException()
+
+    override fun contains(element: F): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun containsAll(elements: Collection<F>): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun get(index: Int): F {
+        throw UnsupportedOperationException()
+    }
+
+    override fun indexOf(element: F): Int {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isEmpty(): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun iterator(): Iterator<F> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun lastIndexOf(element: F): Int {
+        throw UnsupportedOperationException()
+    }
+
+    override fun listIterator(): ListIterator<F> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun listIterator(index: Int): ListIterator<F> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun subList(fromIndex: Int, toIndex: Int): List<F> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun stream() = Stream.of("abc", "ab") as Stream<F>
+}
+
+fun box(): String {
+    val a: List<String> = listOf("abc", "a", "ab")
+    val b = a.stream().filter { it.length > 1 }.collect(Collectors.toList())
+    if (b != listOf("abc", "ab")) return "fail 1"
+
+    val c = B<String>().stream().collect(Collectors.toList())
+    if (c != listOf("abc", "ab")) return "fail 2"
+
+    return "OK"
+}

compiler/testData/codegen/box/jdk/streamBackwardCompatibility.kt

@@ -0,0 +1,9 @@
+// TARGET_BACKEND: JVM
+// LANGUAGE_VERSION: 1.0
+// WITH_RUNTIME
+// FULL_JDK
+class A(val x: List<String>) : List<String> by x
+
+fun box(): String {
+    return A(listOf("OK"))[0]
+}

compiler/testData/codegen/box/jdk/useStream.kt

@@ -0,0 +1,15 @@
+// TARGET_BACKEND: JVM
+// KT-5190 Java 8 Stream.collect couldn't be called
+// WITH_RUNTIME
+// FULL_JDK
+
+import java.util.stream.Collectors
+import java.util.stream.Stream
+
+fun box(): String {
+    val mutableListOf = mutableListOf("OK", "B", "C")
+
+    return test((mutableListOf as java.util.Collection<String>).stream()) as String
+}
+
+fun test(a: Stream<String>) = a.collect(Collectors.toList()).first()

compiler/testData/codegen/box/jvm8/bridgeInClass.kt

@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Test<T> {
+    fun test(p: T): T {
+        return p
+    }
+}
+
+class TestClass : Test<String> {
+    override fun test(p: String): String {
+        return p + "K"
+    }
+}
+
+fun <T> execute(t: Test<T>, p: T): T {
+    return t.test(p)
+}
+
+fun box(): String {
+    return execute(TestClass(), "O")
+}

compiler/testData/codegen/box/jvm8/bridgeInInterface.kt

@@ -0,0 +1,25 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Test<T> {
+    fun test(p: T): T {
+        return p
+    }
+}
+
+interface Test2: Test<String> {
+    override fun test(p: String): String {
+        return p + "K"
+    }
+}
+
+class TestClass : Test2 {
+}
+
+fun <T> execute(t: Test<T>, p: T): T {
+    return t.test(p)
+}
+
+fun box(): String {
+    return execute(TestClass(), "O")
+}

compiler/testData/codegen/box/jvm8/capturedSuperCall.kt

@@ -0,0 +1,30 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// FILE: IBase.java
+
+interface IBase {
+    default String bar() {
+        return "OK";
+    }
+}
+
+// FILE: Kotlin.kt
+open class Base {
+    fun foo() = "OK"
+}
+
+class C : Base(), IBase {
+    val lambda1 = {
+        super.foo()
+    }
+
+    val lambda2 = {
+        super.bar()
+    }
+}
+
+fun box(): String {
+    if (C().lambda1() != "OK") return "fail 1"
+
+    return C().lambda2()
+}

compiler/testData/codegen/box/jvm8/defaultArgs.kt

@@ -0,0 +1,14 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Z {
+    fun test(s: String = "OK"): String {
+        return s
+    }
+}
+
+class Test: Z
+
+fun box(): String {
+    return Test().test()
+}

compiler/testData/codegen/box/jvm8/defaults/accessor.kt

@@ -0,0 +1,38 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+var storage = "fail"
+
+interface Test {
+
+    @JvmDefault
+    private var foo: String
+        get() = storage
+        set(value) {
+            storage = value
+        }
+
+    @JvmDefault
+    private fun bar(): String {
+        return "K"
+    }
+
+    @JvmDefault
+    fun call(): String {
+        return {
+            foo = "O"
+            foo + bar()
+        } ()
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    return TestClass().call()
+}

compiler/testData/codegen/box/jvm8/defaults/accessorFromCompanion.kt

@@ -0,0 +1,28 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    private val foo: String
+        get() = "O"
+
+    @JvmDefault
+    private fun bar(): String {
+        return "K"
+    }
+
+    companion object {
+        fun call(test: Test): String {
+            return test.foo + test.bar()
+        }
+    }
+}
+
+class TestClass : Test
+
+fun box(): String {
+    return Test.call(TestClass())
+}

compiler/testData/codegen/box/jvm8/defaults/accessorsFromDefaultImpls.kt

@@ -0,0 +1,28 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    private val foo: String
+        get() = "O"
+
+    @JvmDefault
+    private fun bar(): String {
+        return "K"
+    }
+
+    fun call(): String {
+        return { foo + bar()} ()
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    return TestClass().call()
+}

compiler/testData/codegen/box/jvm8/defaults/bridgeInClass.kt

@@ -0,0 +1,26 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test<T> {
+    @JvmDefault
+    fun test(p: T): T {
+        return p
+    }
+}
+
+class TestClass : Test<String> {
+    override fun test(p: String): String {
+        return p + "K"
+    }
+}
+
+fun <T> execute(t: Test<T>, p: T): T {
+    return t.test(p)
+}
+
+fun box(): String {
+    return execute(TestClass(), "O")
+}

compiler/testData/codegen/box/jvm8/defaults/bridgeInInterface.kt

@@ -0,0 +1,30 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test<T> {
+    @JvmDefault
+    fun test(p: T): T {
+        return p
+    }
+}
+
+interface Test2: Test<String> {
+    @JvmDefault
+    override fun test(p: String): String {
+        return p + "K"
+    }
+}
+
+class TestClass : Test2 {
+}
+
+fun <T> execute(t: Test<T>, p: T): T {
+    return t.test(p)
+}
+
+fun box(): String {
+    return execute(TestClass(), "O")
+}

compiler/testData/codegen/box/jvm8/defaults/bridgeInInterface2.kt

@@ -0,0 +1,68 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test<T> {
+    @JvmDefault
+    fun test(p: T): T {
+        return null!!
+    }
+
+    fun foo(p: T): T {
+        return null!!
+    }
+}
+
+interface Test2: Test<String> {
+    @JvmDefault
+    override fun test(p: String): String {
+        return p
+    }
+
+    override fun foo(p: String): String {
+        return p
+    }
+}
+
+class TestClass : Test2
+
+fun box(): String {
+    checkNoMethod(Test2::class.java, "foo", Any::class.java)
+    checkMethodExists(Test2::class.java, "test", Any::class.java)
+
+    checkNoMethod(TestClass::class.java, "test", Any::class.java)
+    checkMethodExists(TestClass::class.java, "foo", String::class.java)
+    checkMethodExists(TestClass::class.java, "foo", Any::class.java)
+
+
+    val test2DefaultImpls = java.lang.Class.forName("Test2\$DefaultImpls")
+    checkNoMethod(test2DefaultImpls, "test", Any::class.java)
+    checkNoMethod(test2DefaultImpls, "test", String::class.java)
+    checkMethodExists(test2DefaultImpls, "foo", Test2::class.java, String::class.java)
+
+    return "OK"
+}
+
+fun checkNoMethod(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+    }
+    catch (e: NoSuchMethodException) {
+        return
+    }
+    throw AssertionError("fail: method $name was found in " + clazz)
+}
+
+fun checkMethodExists(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+        return
+    }
+    catch (e: NoSuchMethodException) {
+        throw AssertionError("fail: method $name was not found in " + clazz, e)
+    }
+
+}

compiler/testData/codegen/box/jvm8/defaults/bridgeInInterfaceWithProperties.kt

@@ -0,0 +1,35 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test<T> {
+    @JvmDefault
+    var test: T
+        get() = null!!
+        set(value) {
+            null!!
+        }
+}
+var result = "fail"
+
+interface Test2 : Test<String> {
+    @JvmDefault
+    override var test: String
+        get() = result
+        set(value) {
+            result = value
+        }
+}
+
+class TestClass : Test2
+
+fun <T> execute(t: Test<T>, p: T): T {
+    t.test = p
+    return t.test
+}
+
+fun box(): String {
+    return execute(TestClass(), "OK")
+}

compiler/testData/codegen/box/jvm8/defaults/bridgeInInterfaceWithProperties2.kt

@@ -0,0 +1,82 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test<T> {
+    @JvmDefault
+    var T.test: T
+        get() = null!!
+        set(value) {
+            null!!
+        }
+
+    var T.foo: T
+        get() = null!!
+        set(value) {
+            null!!
+        }
+}
+
+interface Test2 : Test<String> {
+    @JvmDefault
+    override var String.test: String
+        get() = ""
+        set(value) {}
+
+    override var String.foo: String
+        get() = ""
+        set(value) {}
+}
+
+class TestClass : Test2
+
+fun box(): String {
+    checkMethodExists(Test2::class.java, "getTest", String::class.java)
+    checkMethodExists(Test2::class.java, "getTest", Any::class.java)
+    checkMethodExists(Test2::class.java, "setTest", Any::class.java, Any::class.java)
+    checkMethodExists(Test2::class.java, "setTest", String::class.java, String::class.java)
+
+    checkNoMethod(Test2::class.java, "setFoo", Any::class.java, Any::class.java)
+
+    checkNoMethod(TestClass::class.java, "getTest", String::class.java)
+    checkNoMethod(TestClass::class.java, "getTest", Any::class.java)
+    checkNoMethod(TestClass::class.java, "setTest", Any::class.java, Any::class.java)
+    checkNoMethod(TestClass::class.java, "setTest", String::class.java, String::class.java)
+
+    checkMethodExists(TestClass::class.java, "getFoo", String::class.java)
+    checkMethodExists(TestClass::class.java, "getFoo", Any::class.java)
+    checkMethodExists(TestClass::class.java, "setFoo", Any::class.java, Any::class.java)
+    checkMethodExists(TestClass::class.java, "setFoo", String::class.java, String::class.java)
+
+    val test2DefaultImpls = java.lang.Class.forName("Test2\$DefaultImpls")
+    checkNoMethod(test2DefaultImpls, "getTest", String::class.java)
+    checkNoMethod(test2DefaultImpls, "getTest", Any::class.java)
+    checkNoMethod(test2DefaultImpls, "setTest", Any::class.java, Any::class.java)
+    checkNoMethod(test2DefaultImpls, "setTest", String::class.java, String::class.java)
+
+    return "OK"
+}
+
+fun checkNoMethod(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+    }
+    catch (e: NoSuchMethodException) {
+        return
+    }
+    throw AssertionError("fail: method $name was found in " + clazz)
+}
+
+fun checkMethodExists(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+        return
+    }
+    catch (e: NoSuchMethodException) {
+        throw AssertionError("fail: method $name was not found in " + clazz, e)
+    }
+
+}

compiler/testData/codegen/box/jvm8/defaults/bridgeWithJava.kt

@@ -0,0 +1,60 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+// FILE: Test.java
+public interface Test<T> {
+    default T test(T p) {
+        return null;
+    }
+}
+
+// FILE: kotlin.kt
+
+interface Test2: Test<String> {
+    @JvmDefault
+    override fun test(p: String): String {
+        return p
+    }
+
+    fun forDefaultImpls() {}
+}
+
+class TestClass : Test2
+
+fun box(): String {
+    checkMethodExists(Test2::class.java, "test", String::class.java)
+    checkMethodExists(Test2::class.java, "test", Any::class.java)
+
+    checkNoMethod(TestClass::class.java, "test", String::class.java)
+    checkNoMethod(TestClass::class.java, "test", Any::class.java)
+
+    val test2DefaultImpls = java.lang.Class.forName("Test2\$DefaultImpls")
+    checkNoMethod(test2DefaultImpls, "test", Any::class.java)
+    checkNoMethod(test2DefaultImpls, "test", String::class.java)
+
+    return "OK"
+}
+
+fun checkNoMethod(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+    }
+    catch (e: NoSuchMethodException) {
+        return
+    }
+    throw AssertionError("fail: method $name was found in " + clazz)
+}
+
+fun checkMethodExists(clazz: Class<*>, name: String, vararg parameterTypes: Class<*>) {
+    try {
+        clazz.getDeclaredMethod(name, *parameterTypes)
+        return
+    }
+    catch (e: NoSuchMethodException) {
+        throw AssertionError("fail: method $name was not found in " + clazz, e)
+    }
+
+}

compiler/testData/codegen/box/jvm8/defaults/callableReference.kt

@@ -0,0 +1,26 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun foo(): String = "O"
+
+    @JvmDefault
+    val bar: String
+        get() = "K"
+
+    fun test(): String {
+        return (::foo)() + (::bar)()
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    return TestClass().test()
+}

compiler/testData/codegen/box/jvm8/defaults/capturedSuperCall.kt

@@ -0,0 +1,30 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface IBase {
+    @JvmDefault
+    fun bar() = "OK"
+}
+
+open class Base {
+    fun foo() = "OK"
+}
+
+class C : Base(), IBase {
+    val lambda1 = {
+        super.foo()
+    }
+
+    val lambda2 = {
+        super.bar()
+    }
+}
+
+fun box(): String {
+    if (C().lambda1() != "OK") return "fail 1"
+
+    return C().lambda2()
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/bridge.kt

@@ -0,0 +1,39 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.test2(this, "OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    @JvmDefault
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+
+fun box(): String {
+
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2("OK")
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/bridge2.kt

@@ -0,0 +1,37 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.test2(this, "OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String test2(String p) {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    @JvmDefault
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/bridge3.kt

@@ -0,0 +1,41 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface3 {
+    default String test() {
+        return KInterface3.DefaultImpls.test2(this, "OK");
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String test2(String p) {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+    @JvmDefault
+    fun test2(p: T): T {
+        return p
+    }
+}
+
+interface KInterface2 : KInterface<String> {
+
+}
+
+interface KInterface3 : KInterface2 {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/bridgeWithProperties.kt

@@ -0,0 +1,44 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.getBar(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    @JvmDefault
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    @JvmDefault
+    override val foo: String
+        get() = "OK"
+}
+
+
+fun box(): String {
+
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().bar
+
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/bridgeWithProperties2.kt

@@ -0,0 +1,41 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.getBar(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+    public String getBar() {
+        return "fail";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    @JvmDefault
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    @JvmDefault
+    override val foo: String
+        get() = "OK"
+}
+
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/bridgeWithProperties3.kt

@@ -0,0 +1,43 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface3 {
+    default String test() {
+        return KInterface3.DefaultImpls.getBar(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface<T>  {
+
+    val foo: T
+
+    @JvmDefault
+    val bar: T
+        get() = foo
+}
+
+interface KInterface2 : KInterface<String> {
+    @JvmDefault
+    override val foo: String
+        get() = "OK"
+}
+
+interface KInterface3 : KInterface2 {
+
+}
+
+
+fun box(): String {
+    return Foo().test()
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/defaultArgs.kt

@@ -0,0 +1,23 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+interface Test {
+    @JvmDefault
+    fun test(s: String ="OK"): String {
+        return s
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    val defaultImpls = java.lang.Class.forName(Test::class.java.canonicalName + "\$DefaultImpls")
+
+    val declaredMethod = defaultImpls.getDeclaredMethod("test\$default", Test::class.java, String::class.java, Int::class.java, Any::class.java)
+    return declaredMethod.invoke(null, TestClass(), null, 1, null) as String
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/inheritedJvmDefault.kt

@@ -0,0 +1,38 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface2 {
+    default String test() {
+        return KInterface2.DefaultImpls.test2(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    @JvmDefault
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+interface KInterface2 : KInterface {
+
+}
+
+
+fun box(): String {
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2()
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/propertyAnnotation.kt

@@ -0,0 +1,25 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+
+annotation class Property(val value: String)
+annotation class Accessor(val value: String)
+
+interface Z {
+    @Property("OK")
+    @JvmDefault
+    val z: String
+        @Accessor("OK")
+        get() = "OK"
+}
+
+
+class Test : Z
+
+fun box() : String {
+    val value = Z::z.annotations.filterIsInstance<Property>().single().value
+    if (value != "OK") return value
+    return (Z::z.getter.annotations.single() as Accessor).value
+}

compiler/testData/codegen/box/jvm8/defaults/compatibility/simpleFunction.kt

@@ -0,0 +1,34 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: compatibility
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple extends KInterface {
+    default String test() {
+        return KInterface.DefaultImpls.test2(this);
+    }
+}
+
+// FILE: Foo.java
+public class Foo implements Simple {
+
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KInterface  {
+    @JvmDefault
+    fun test2(): String {
+        return "OK"
+    }
+}
+
+
+fun box(): String {
+    val result = Foo().test()
+    if (result != "OK") return "fail 1: ${result}"
+
+    return Foo().test2()
+}

compiler/testData/codegen/box/jvm8/defaults/defaultArgs.kt

@@ -0,0 +1,17 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+interface Z {
+    @JvmDefault
+    fun test(s: String = "OK"): String {
+        return s
+    }
+}
+
+class Test: Z
+
+fun box(): String {
+    return Test().test()
+}

compiler/testData/codegen/box/jvm8/defaults/delegationBy/simple.kt

@@ -0,0 +1,33 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "O"
+    }
+
+    fun delegatedTest(): String {
+        return "fail"
+    }
+}
+
+class Delegate : Test {
+    override fun test(): String {
+        return "Fail"
+    }
+
+    override fun delegatedTest(): String {
+        return "K"
+    }
+}
+
+class TestClass(val foo: Test) : Test by foo
+
+fun box(): String {
+    val testClass = TestClass(Delegate())
+    return testClass.test() + testClass.delegatedTest()
+}

compiler/testData/codegen/box/jvm8/defaults/delegationBy/simpleProperty.kt

@@ -0,0 +1,30 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    val test: String
+        get() = "O"
+
+    val testDelegated: String
+        get() = "fail"
+
+}
+
+class Delegate : Test {
+    override val test: String
+        get() = "fail"
+
+    override val testDelegated: String
+        get() = "K"
+}
+
+class TestClass(val foo: Test) : Test by foo
+
+fun box(): String {
+    val testClass = TestClass(Delegate())
+    return testClass.test + testClass.testDelegated
+}

compiler/testData/codegen/box/jvm8/defaults/diamond.kt

@@ -0,0 +1,54 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+// FULL_JDK
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "Test"
+    }
+}
+
+open class TestClass : Test {
+
+}
+
+
+interface Test2 : Test {
+    @JvmDefault
+    override fun test(): String {
+        return "Test2"
+    }
+}
+
+interface Test3 : Test2 {
+
+}
+
+
+class TestClass2 : TestClass(), Test3 {
+
+}
+
+fun box(): String {
+    val test = TestClass2().test()
+    if (test != "Test2") return "fail 1: $test"
+    checkNoMethod(TestClass::class.java, "test")
+    checkNoMethod(Test3::class.java, "test")
+    checkNoMethod(TestClass2::class.java, "test")
+
+    return "OK"
+}
+
+fun checkNoMethod(clazz: Class<*>, name: String) {
+    try {
+        clazz.getDeclaredMethod(name)
+    }
+    catch (e: NoSuchMethodException) {
+        return
+    }
+    throw AssertionError("fail " + clazz)
+}

compiler/testData/codegen/box/jvm8/defaults/inline.kt

@@ -0,0 +1,29 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return inlineFun { "O" }
+    }
+
+    fun testDefaultImpls(): String {
+        return inlineFun { "K" }
+    }
+
+    @JvmDefault
+    private inline fun inlineFun(s: () -> String) = s()
+
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    val foo = TestClass()
+    return foo.test() + foo.testDefaultImpls()
+}

compiler/testData/codegen/box/jvm8/defaults/inlineProperty.kt

@@ -0,0 +1,31 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return inlineProp
+    }
+
+    fun testDefaultImpls(): String {
+        return inlineProp
+    }
+
+    @JvmDefault
+    private inline val inlineProp: String
+        get() = "OK"
+
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    val foo = TestClass()
+    if (foo.test() != "OK") return "fail: ${foo.test()}"
+    return foo.testDefaultImpls()
+}

compiler/testData/codegen/box/jvm8/defaults/kt11969.kt

@@ -0,0 +1,62 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Z {
+
+    @JvmDefault
+    private fun privateFun() = { "OK" }
+
+    @JvmDefault
+    fun callPrivateFun() = privateFun()
+
+    @JvmDefault
+    fun publicFun() = { "OK" }
+
+    @JvmDefault
+    fun funWithDefaultArgs(s: () -> Unit = {}): () -> Unit
+
+    @JvmDefault
+    val property: () -> Unit
+        get() = {}
+
+    class Nested
+}
+
+class Test : Z {
+    override fun funWithDefaultArgs(s: () -> Unit): () -> Unit {
+        return s
+    }
+}
+
+fun box(): String {
+
+    val privateFun = Test().callPrivateFun()
+    var enclosing = privateFun.javaClass.enclosingMethod!!
+    if (enclosing.name != "privateFun") return "fail 1: ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "Z") return "fail 2: ${enclosing.getDeclaringClass().simpleName}"
+
+    val publicFun = Test().publicFun()
+    enclosing = publicFun.javaClass.enclosingMethod!!
+    if (enclosing.name != "publicFun") return "fail 3: ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "Z") return "fail 4: ${enclosing.getDeclaringClass().simpleName}"
+
+    val property = Test().property
+    enclosing = property.javaClass.enclosingMethod!!
+    if (enclosing.name != "getProperty") return "fail 4: ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "Z") return "fail 5: ${enclosing.getDeclaringClass().simpleName}"
+
+    val defaultArgs = Test().funWithDefaultArgs()
+    enclosing = defaultArgs.javaClass.enclosingMethod!!
+    if (enclosing.name != "funWithDefaultArgs\$default") return "fail 6: ${enclosing.name}"
+    if (enclosing.parameterTypes.size != 4) return "fail 7: not default method ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "Z") return "fail 8: ${enclosing.getDeclaringClass().simpleName}"
+
+    val nested = Z.Nested::class.java
+    val enclosingClass = nested.enclosingClass!!
+    if (enclosingClass.name != "Z") return "fail 9: ${enclosingClass.name}"
+
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/defaults/kt14243.kt

@@ -0,0 +1,25 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Z<T> {
+    @JvmDefault
+    fun test(p: T): T {
+        return p
+    }
+}
+
+open class ZImpl : Z<String>
+
+class ZImpl2 : ZImpl() {
+
+    override fun test(p: String): String {
+        return super.test(p)
+    }
+}
+
+fun box(): String {
+    return ZImpl2().test("OK")
+}

compiler/testData/codegen/box/jvm8/defaults/kt14243_2.kt

@@ -0,0 +1,27 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Z<T> {
+    @JvmDefault
+    fun test(p: T): T {
+        return p
+    }
+}
+
+open class ZImpl : Z<String>
+
+open class ZImpl2 : Z<String>, ZImpl()
+
+class ZImpl3 : ZImpl2() {
+
+    override fun test(p: String): String {
+        return super.test(p)
+    }
+}
+
+fun box(): String {
+    return ZImpl3().test("OK")
+}

compiler/testData/codegen/box/jvm8/defaults/kt14243_prop.kt

@@ -0,0 +1,29 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Z<T> {
+
+    val value: T
+
+    @JvmDefault
+    val z: T
+        get() = value
+}
+
+open class ZImpl : Z<String> {
+    override val value: String
+        get() = "OK"
+}
+
+open class ZImpl2 : ZImpl() {
+    override val z: String
+        get() = super.z
+}
+
+
+fun box(): String {
+    return ZImpl2().value
+}

compiler/testData/codegen/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInClass.kt

@@ -0,0 +1,26 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test {
+    @JvmDefault
+    fun test() {
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    try {
+        TestClass::class.java.getDeclaredMethod("test")
+    }
+    catch (e: NoSuchMethodException) {
+        return "OK"
+    }
+    return "fail"
+}

compiler/testData/codegen/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInInterface.kt

@@ -0,0 +1,26 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test {
+    @JvmDefault
+    fun test() {
+    }
+}
+
+interface Test2 : Test {
+
+}
+
+fun box(): String {
+    try {
+        Test2::class.java.getDeclaredMethod("test")
+    }
+    catch (e: NoSuchMethodException) {
+        return "OK"
+    }
+    return "fail"
+}

compiler/testData/codegen/box/jvm8/defaults/noDelegation/noDelegationToDefaultMethodInInterface2.kt

@@ -0,0 +1,30 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// FULL_JDK
+
+interface Test {
+    @JvmDefault
+    fun test() {
+    }
+}
+
+interface Test2 : Test {
+
+}
+
+interface Test3 : Test2 {
+
+}
+
+fun box(): String {
+    try {
+        Test3::class.java.getDeclaredMethod("test")
+    }
+    catch (e: NoSuchMethodException) {
+        return "OK"
+    }
+    return "fail"
+}

compiler/testData/codegen/box/jvm8/defaults/oneImplementation.kt

@@ -0,0 +1,26 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KCallable {
+    @JvmDefault
+    val returnType: String
+}
+
+interface KCallableImpl : KCallable {
+    @JvmDefault
+    override val returnType: String
+        get() = "OK"
+}
+
+interface KCallableImpl2 : KCallableImpl
+
+open class DescriptorBasedProperty : KCallableImpl
+open class KProperty1Impl : DescriptorBasedProperty(), KCallableImpl2
+open class KMutableProperty1Impl : KProperty1Impl(), KCallable
+
+fun box(): String {
+    return KMutableProperty1Impl().returnType
+}

compiler/testData/codegen/box/jvm8/defaults/oneImplementation2.kt

@@ -0,0 +1,31 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface KCallable {
+    @JvmDefault
+    val returnType: String
+}
+
+interface KCallableImpl : KCallable {
+    @JvmDefault
+    override val returnType: String
+        get() = "OK"
+}
+
+interface KProperty : KCallable
+interface KPropertyImpl : KProperty, KCallableImpl
+interface KMutableProperty : KProperty
+interface KProperty1 : KProperty
+interface KMutableProperty1 : KProperty1, KMutableProperty
+interface KMutablePropertyImpl : KPropertyImpl
+
+open class DescriptorBasedProperty : KCallableImpl
+open class KProperty1Impl : DescriptorBasedProperty(), KProperty1, KPropertyImpl
+open class KMutableProperty1Impl : KProperty1Impl(), KMutableProperty1, KMutablePropertyImpl
+
+fun box(): String {
+    return KMutableProperty1Impl().returnType
+}

compiler/testData/codegen/box/jvm8/defaults/privateDefaultFromDefaultImpl.kt

@@ -0,0 +1,26 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    fun test(): String {
+        return privateFun() + privateProp
+    }
+
+    @JvmDefault
+    private fun privateFun(): String {
+        return "O"
+    }
+
+    @JvmDefault
+    private val privateProp: String
+        get() = "K"
+}
+
+class TestImpl: Test
+
+fun box(): String {
+    return TestImpl().test()
+}

compiler/testData/codegen/box/jvm8/defaults/privateInDefaultImpls.kt

@@ -0,0 +1,25 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return privateFun() + privateProp
+    }
+
+    private fun privateFun(): String {
+        return "O"
+    }
+
+    private val privateProp: String
+        get() = "K"
+}
+
+class TestImpl: Test
+
+fun box(): String {
+    return TestImpl().test()
+}

compiler/testData/codegen/box/jvm8/defaults/reflection/propertyAnnotations.kt

@@ -0,0 +1,25 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+
+annotation class Property(val value: String)
+annotation class Accessor(val value: String)
+
+interface Z {
+    @Property("OK")
+    @JvmDefault
+    val z: String
+        @Accessor("OK")
+        get() = "OK"
+}
+
+
+class Test : Z
+
+fun box() : String {
+    val value = Z::z.annotations.filterIsInstance<Property>().single().value
+    if (value != "OK") return value
+    return (Z::z.getter.annotations.single() as Accessor).value
+}

compiler/testData/codegen/box/jvm8/defaults/simpleCall.kt

@@ -0,0 +1,20 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "OK"
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    return TestClass().test()
+}

compiler/testData/codegen/box/jvm8/defaults/simpleProperty.kt

@@ -0,0 +1,18 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Z {
+    @JvmDefault
+    val z: String
+        get() = "OK"
+}
+
+
+class Test : Z
+
+fun box() : String {
+    return Test().z
+}

compiler/testData/codegen/box/jvm8/defaults/superCall.kt

@@ -0,0 +1,29 @@
+// !API_VERSION: 1.3
+// !JVM_DEFAULT_MODE: enable
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Test {
+    @JvmDefault
+    fun test(): String {
+        return "OK"
+    }
+}
+
+interface Test2 : Test {
+    @JvmDefault
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+
+class TestClass : Test2 {
+
+}
+
+
+fun box(): String {
+    return TestClass().test()
+}

compiler/testData/codegen/box/jvm8/inlineFromAnotherFile.kt

@@ -0,0 +1,20 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+//WITH_RUNTIME
+
+// FILE: 1.kt
+package test
+
+public inline fun <T, R> Iterable<T>.fold2(initial: R, operation: (R, T) -> R): R {
+    var accumulator = initial
+    for (element in this) accumulator = operation(accumulator, element)
+    return accumulator
+}
+
+// FILE: 2.kt
+import test.*
+
+fun box(): String {
+    val list = listOf("O", "K")
+    return list.fold2("") {a, b -> a +b}
+}

compiler/testData/codegen/box/jvm8/inlineFromStdlib.kt

@@ -0,0 +1,9 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+//WITH_RUNTIME
+
+fun box(): String {
+    val list = listOf("O", "K")
+    return list.fold("") {a, b -> a +b}
+}
+

compiler/testData/codegen/box/jvm8/interfaceFlag/superCall.kt

@@ -0,0 +1,25 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple {
+    default String test() {
+        return "O";
+    }
+
+    static String testStatic() {
+        return "K";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+class TestClass : Simple {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+
+fun box(): String {
+    return TestClass().test() + Simple.testStatic()
+}

compiler/testData/codegen/box/jvm8/interfaceFlag/superCallIndirect.kt

@@ -0,0 +1,27 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple {
+    default String test() {
+        return "O";
+    }
+
+    static String testStatic() {
+        return "K";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+interface KSimple : Simple {}
+
+class TestClass : KSimple {
+    override fun test(): String {
+        return super.test()
+    }
+}
+
+
+fun box(): String {
+    return TestClass().test() + Simple.testStatic()
+}

compiler/testData/codegen/box/jvm8/javaDefaults/capturedSuperCall.kt

@@ -0,0 +1,30 @@
+// TARGET_BACKEND: JVM
+// FILE: IBase.java
+
+interface IBase {
+    default String bar() {
+        return "OK";
+    }
+}
+
+// FILE: Kotlin.kt
+// JVM_TARGET: 1.8
+open class Base {
+    fun foo() = "OK"
+}
+
+class C : Base(), IBase {
+    val lambda1 = {
+        super.foo()
+    }
+
+    val lambda2 = {
+        super.bar()
+    }
+}
+
+fun box(): String {
+    if (C().lambda1() != "OK") return "fail 1"
+
+    return C().lambda2()
+}

compiler/testData/codegen/box/jvm8/javaDefaults/defaultMethodCallFromInterface.kt

@@ -0,0 +1,29 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple {
+    default String test(String s) {
+        return s + "K";
+    }
+
+    static String testStatic(String s) {
+        return s + "K";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+interface KInterface : Simple {
+    fun bar(): String {
+        return test("O") + Simple.testStatic("O")
+    }
+}
+
+class Test : KInterface {}
+
+fun box(): String {
+    val test = Test().bar()
+    if (test != "OKOK") return "fail $test"
+
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/javaDefaults/defaultMethodCallViaClass.kt

@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+interface Simple {
+    default String test(String s) {
+        return s + "K";
+    }
+
+    static String testStatic(String s) {
+        return s + "K";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+class Test : Simple {}
+
+fun box(): String {
+    val test = Test().test("O")
+    if (test != "OK") return "fail $test"
+
+    return Simple.testStatic("O")
+}

compiler/testData/codegen/box/jvm8/javaDefaults/defaultMethodCallViaInterface.kt

@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple {
+    default String test(String s) {
+        return s + "K";
+    }
+
+    static String testStatic(String s) {
+        return s + "K";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+interface TestInterface : Simple {}
+class Test : TestInterface {}
+
+fun box(): String {
+    val test = Test().test("O")
+    if (test != "OK") return "fail $test"
+
+    return Simple.testStatic("O")
+}

compiler/testData/codegen/box/jvm8/javaDefaults/defaultMethodOverride.kt

@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+public interface Simple {
+    default String test(String s) {
+        return s + "Fail";
+    }
+}
+
+// FILE: main.kt
+
+interface KInterface: Simple {
+    override fun test(s: String): String {
+        return s + "K"
+    }
+}
+
+class Test : KInterface {
+
+}
+
+fun box(): String {
+    return Test().test("O")
+}

compiler/testData/codegen/box/jvm8/javaDefaults/dontDelegateToDefaultMethods.kt

@@ -0,0 +1,25 @@
+// TARGET_BACKEND: JVM
+// FILE: Test.java
+
+interface Test<T> {
+
+    T call();
+
+    default T testDefault(T p) {
+        return p;
+    }
+}
+
+// FILE: main.kt
+
+class Child : Test<String> {
+    override fun call() : String {
+        return "OK"
+    }
+}
+fun box(): String {
+    val res = Child().call()
+    if (res != "OK") return "fail $res"
+
+    return Child().testDefault("OK")
+}

compiler/testData/codegen/box/jvm8/javaDefaults/inheritKotlin.kt

@@ -0,0 +1,32 @@
+// TARGET_BACKEND: JVM
+// FILE: Simple.java
+
+interface Simple extends KInterface {
+    default String test() {
+        return "simple";
+    }
+}
+
+// FILE: main.kt
+// JVM_TARGET: 1.8
+interface KInterface {
+    fun test(): String {
+        return "base";
+    }
+}
+
+class Test : Simple {
+    fun bar(): String {
+        return super.test()
+    }
+}
+
+fun box(): String {
+    val test = Test().test()
+    if (test != "simple") return "fail $test"
+
+    val bar = Test().bar()
+    if (bar != "simple") return "fail 2 $bar"
+
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/javaDefaults/invokeDefaultViaSuper.kt

@@ -0,0 +1,43 @@
+// TARGET_BACKEND: JVM
+// FILE: Test.java
+
+public interface Test {
+    default String test() {
+        return "OK";
+    }
+}
+
+// FILE: test.kt
+// JVM_TARGET: 1.8
+interface KInterface : Test {
+
+}
+
+class KClass : Test {
+    fun ktest(): String {
+        return super.test() + test()
+    }
+}
+
+class KTClass : KInterface {
+    fun ktest(): String {
+        return super.test() + test()
+    }
+}
+
+
+fun box(): String {
+    val p = object : KInterface {
+        fun ktest(): String {
+            return super.test() + test()
+        }
+    }.ktest()
+
+    if (p != "OKOK") return "fail1: $p"
+
+    if (KClass().ktest() != "OKOK") return "fail 2: ${KClass().ktest()}"
+
+    if (KTClass().ktest() != "OKOK") return "fail 3: ${KTClass().ktest()}"
+
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/javaDefaults/invokeDefaultViaSuper_16.kt

@@ -0,0 +1,46 @@
+// TARGET_BACKEND: JVM
+// FILE: Test.java
+
+public interface Test {
+    default String test() {
+        return "OK";
+    }
+}
+
+// FILE: test.kt
+
+interface KInterface : Test {
+
+}
+
+class KClass : Test {
+    @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR")
+    fun ktest(): String {
+        return super.test() + test()
+    }
+}
+
+class KTClass : KInterface {
+    @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR")
+    fun ktest(): String {
+        return super.test() + test()
+    }
+}
+
+
+fun box(): String {
+    val p = object : KInterface {
+        @kotlin.Suppress("DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR")
+        fun ktest(): String {
+            return super.test() + test()
+        }
+    }.ktest()
+
+    if (p != "OKOK") return "fail1: $p"
+
+    if (KClass().ktest() != "OKOK") return "fail 2: ${KClass().ktest()}"
+
+    if (KTClass().ktest() != "OKOK") return "fail 3: ${KTClass().ktest()}"
+
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/javaDefaults/longChainOfKotlinExtendsFromJavaWithDefault.kt

@@ -0,0 +1,22 @@
+// TARGET_BACKEND: JVM
+// FILE: Base.java
+
+public interface Base {
+    default String foo() {
+        return "OK";
+    }
+}
+
+// FILE: derived.kt
+// JVM_TARGET: 1.8
+interface K1 : Base
+
+interface K2 : K1
+
+interface K3 : K2
+
+class C : K3 {
+    override fun foo() = super.foo()
+}
+
+fun box(): String = C().foo()

compiler/testData/codegen/box/jvm8/javaDefaults/samOnInterfaceWithDefaultMethod.kt

@@ -0,0 +1,29 @@
+// TARGET_BACKEND: JVM
+// FILE: JavaCall.java
+
+class JavaCall {
+    String call(Test test) {
+        return test.call();
+    }
+}
+
+// FILE: Test.java
+
+interface Test {
+
+    String call();
+
+    default String test() {
+        return "K";
+    }
+
+    static String testStatic() {
+        return "K";
+    }
+}
+
+// FILE: sam.kt
+
+fun box(): String {
+    return JavaCall().call {"OK"}
+}

compiler/testData/codegen/box/jvm8/kt11969.kt

@@ -0,0 +1,54 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+
+interface Z {
+    private fun privateFun() = { "OK" }
+
+    fun callPrivateFun() = privateFun()
+
+    fun publicFun() = { "OK" }
+
+    fun funWithDefaultArgs(s: () -> Unit = {}): () -> Unit
+
+    val property: () -> Unit
+        get() = {}
+
+    class Nested
+}
+
+class Test : Z {
+    override fun funWithDefaultArgs(s: () -> Unit): () -> Unit {
+        return s
+    }
+}
+
+fun box(): String {
+
+    val privateFun = Test().callPrivateFun()
+    var enclosing = privateFun.javaClass.enclosingMethod!!
+    if (enclosing.name != "privateFun") return "fail 1: ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "DefaultImpls") return "fail 2: ${enclosing.getDeclaringClass().simpleName}"
+
+    val publicFun = Test().publicFun()
+    enclosing = publicFun.javaClass.enclosingMethod!!
+    if (enclosing.name != "publicFun") return "fail 3: ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "DefaultImpls") return "fail 4: ${enclosing.getDeclaringClass().simpleName}"
+
+    val property = Test().property
+    enclosing = property.javaClass.enclosingMethod!!
+    if (enclosing.name != "getProperty") return "fail 4: ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "DefaultImpls") return "fail 5: ${enclosing.getDeclaringClass().simpleName}"
+
+    val defaultArgs = Test().funWithDefaultArgs()
+    enclosing = defaultArgs.javaClass.enclosingMethod!!
+    if (enclosing.name != "funWithDefaultArgs\$default") return "fail 6: ${enclosing.name}"
+    if (enclosing.parameterTypes.size != 4) return "fail 7: not default method ${enclosing.name}"
+    if (enclosing.getDeclaringClass().simpleName != "DefaultImpls") return "fail 8: ${enclosing.getDeclaringClass().simpleName}"
+
+    val nested = Z.Nested::class.java
+    val enclosingClass = nested.enclosingClass!!
+    if (enclosingClass.name != "Z") return "fail 9: ${enclosingClass.name}"
+
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/kt14243.kt

@@ -0,0 +1,21 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Z<T> {
+    fun test(p: T): T {
+        return p
+    }
+}
+
+open class ZImpl : Z<String>
+
+class ZImpl2 : ZImpl() {
+
+    override fun test(p: String): String {
+        return super.test(p)
+    }
+}
+
+fun box(): String {
+    return ZImpl2().test("OK")
+}

compiler/testData/codegen/box/jvm8/kt14243_2.kt

@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Z<T> {
+    fun test(p: T): T {
+        return p
+    }
+}
+
+open class ZImpl : Z<String>
+
+open class ZImpl2 : Z<String>, ZImpl()
+
+class ZImpl3 : ZImpl2() {
+
+    override fun test(p: String): String {
+        return super.test(p)
+    }
+}
+
+fun box(): String {
+    return ZImpl3().test("OK")
+}

compiler/testData/codegen/box/jvm8/kt14243_prop.kt

@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Z<T> {
+    val value: T
+
+    val z: T
+        get() = value
+}
+
+open class ZImpl : Z<String> {
+    override val value: String
+        get() = "OK"
+}
+
+open class ZImpl2 : ZImpl() {
+    override val z: String
+        get() = super.z
+}
+
+
+fun box(): String {
+    return ZImpl2().value
+}

compiler/testData/codegen/box/jvm8/kt16581.kt

@@ -0,0 +1,10 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+fun failAtRuntime(numberArg: Number = 0.0): Number {
+    return numberArg
+}
+
+fun box(): String {
+    failAtRuntime()
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/kt16581_2.kt

@@ -0,0 +1,18 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+fun test(o: Number) {}
+
+fun test2(o: Number) {
+    val p: Int = 1
+    val o = if (z < 1) p else o
+    test(o)
+}
+
+var z = 1
+
+fun box(): String {
+    val x: Number = 1
+    test2(x)
+    return "OK"
+}

compiler/testData/codegen/box/jvm8/kt16588.kt

@@ -0,0 +1,13 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+fun number(doLong: Boolean): Number = when {
+    doLong -> 1.toLong()
+    else -> 0
+}
+
+fun box(): String {
+    number(true)
+    return "OK"
+}
+

compiler/testData/codegen/box/jvm8/kt6301.kt

@@ -0,0 +1,27 @@
+// !LANGUAGE: +JvmStaticInInterface
+// WITH_RUNTIME
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// FILE: test.kt
+fun box(): String {
+    return Java.test()
+}
+
+interface Foo {
+
+    companion object {
+        @JvmStatic
+        fun foo() = "O"
+
+        @JvmStatic
+        var fooProp = ""
+    }
+}
+
+// FILE: Java.java
+public class Java {
+    public static String test() {
+        Foo.setFooProp("K");
+        return Foo.foo() + Foo.getFooProp();
+    }
+}

compiler/testData/codegen/box/jvm8/kt6301_2.kt

@@ -0,0 +1,27 @@
+// !LANGUAGE: +JvmStaticInInterface
+// WITH_RUNTIME
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// FILE: test.kt
+fun box(): String {
+    return Java.test()
+}
+
+interface Foo {
+
+    companion object {
+        @JvmStatic
+        fun foo() = "O"
+
+
+        val fooProp = "K"
+            @JvmStatic get
+    }
+}
+
+// FILE: Java.java
+public class Java {
+    public static String test() {
+        return Foo.foo() + Foo.getFooProp();
+    }
+}

compiler/testData/codegen/box/jvm8/oneImplementation.kt

@@ -0,0 +1,20 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+interface KCallable {
+    val returnType: String
+}
+
+interface KCallableImpl : KCallable {
+    override val returnType: String
+        get() = "OK"
+}
+
+interface KCallableImpl2 : KCallableImpl
+
+open class DescriptorBasedProperty : KCallableImpl
+open class KProperty1Impl : DescriptorBasedProperty(), KCallableImpl2
+open class KMutableProperty1Impl : KProperty1Impl(), KCallable
+
+fun box(): String {
+    return KMutableProperty1Impl().returnType
+}

compiler/testData/codegen/box/jvm8/oneImplementation2.kt

@@ -0,0 +1,25 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+interface KCallable {
+    val returnType: String
+}
+
+interface KCallableImpl : KCallable {
+    override val returnType: String
+        get() = "OK"
+}
+
+interface KProperty : KCallable
+interface KPropertyImpl : KProperty, KCallableImpl
+interface KMutableProperty : KProperty
+interface KProperty1 : KProperty
+interface KMutableProperty1 : KProperty1, KMutableProperty
+interface KMutablePropertyImpl : KPropertyImpl
+
+open class DescriptorBasedProperty : KCallableImpl
+open class KProperty1Impl : DescriptorBasedProperty(), KProperty1, KPropertyImpl
+open class KMutableProperty1Impl : KProperty1Impl(), KMutableProperty1, KMutablePropertyImpl
+
+fun box(): String {
+    return KMutableProperty1Impl().returnType
+}

compiler/testData/codegen/box/jvm8/simpleCall.kt

@@ -0,0 +1,16 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Test {
+    fun test(): String {
+        return "OK"
+    }
+}
+
+class TestClass : Test {
+
+}
+
+fun box(): String {
+    return TestClass().test()
+}

compiler/testData/codegen/box/jvm8/simpleProperty.kt

@@ -0,0 +1,14 @@
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+
+interface Z {
+    val z: String
+        get() = "OK"
+}
+
+
+class Test : Z
+
+fun box() : String {
+    return Test().z
+}