[Test] Properly merge box against java testdata into codegen/box

Previous commit about it was 3199ce03 and it was completely wrong

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

@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.USE_PSI_CLASS_FILES_READING
+// MODULE: lib
+// FILE: J.java
+
+public @interface J {
+    double minusInf() default Double.NEGATIVE_INFINITY;
+    double plusInf() default Double.POSITIVE_INFINITY;
+    double nan() default Double.NaN;
+    double divisionByZero() default 1.0 / 0.0;
+
+    float minusInfFloat() default Float.NEGATIVE_INFINITY;
+    float plusInfFloat() default Float.POSITIVE_INFINITY;
+    float nanFloat() default Float.NaN;
+    float divisionByZeroFloat() default 1.0f / 0.0f;
+}
+
+// MODULE: main(lib)
+// FILE: K.kt
+
+fun box(): String {
+    // Only check that the compiler loads the class for J
+    J::class
+
+    return "OK"
+}

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

@@ -0,0 +1,43 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    String[] value() default {"d1", "d2"};
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@JavaAnn class MyClass1
+@JavaAnn() class MyClass2
+@JavaAnn("asd") class MyClass3
+@JavaAnn(*arrayOf()) class MyClass4
+
+
+fun box(): String {
+    val value1 = MyClass1::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value1.size != 2) return "fail1: ${value1.size}"
+    if (value1[0] != "d1") return "fail2: ${value1[0]}"
+    if (value1[1] != "d2") return "fail3: ${value1[1]}"
+
+    val value2 = MyClass2::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value2.size != 2) return "fail4: ${value2.size}"
+    if (value2[0] != "d1") return "fail5: ${value2[0]}"
+    if (value2[1] != "d2") return "fail6: ${value2[1]}"
+
+    val value3 = MyClass3::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value3.size != 1) return "fail7: ${value3.size}"
+    if (value3[0] != "asd") return "fail8: ${value3[0]}"
+
+    val value4 = MyClass4::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value4.size != 0) return "fail 9: ${value4.size}"
+
+    return "OK"
+}

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

@@ -0,0 +1,39 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    String[] value();
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@JavaAnn class MyClass1
+@JavaAnn() class MyClass2
+@JavaAnn("asd") class MyClass3
+@JavaAnn(*arrayOf()) class MyClass4
+
+
+fun box(): String {
+    val value1 = MyClass1::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value1.size != 0) return "fail1: ${value1.size}"
+
+    val value2 = MyClass2::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value2.size != 0) return "fail2: ${value2.size}"
+
+    val value3 = MyClass3::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value3.size != 1) return "fail3: ${value3.size}"
+    if (value3[0] != "asd") return "fail4: ${value3[0]}"
+
+    val value4 = MyClass4::class.java.getAnnotation(JavaAnn::class.java).value
+    if (value4.size != 0) return "fail 5: ${value4.size}"
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    String value();
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@JavaAnn("value") class MyClass
+
+fun box(): String {
+    val ann = MyClass::class.java.getAnnotation(JavaAnn::class.java)
+    if (ann == null) return "fail: cannot find Ann on MyClass}"
+    if (ann.value != "value") return "fail: annotation parameter i should be 'value', but was ${ann.value}"
+    return "OK"
+}

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

@@ -0,0 +1,53 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    String value() default "default";
+}
+
+// FILE: JavaAnn2.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn2 {
+    int a() default 1;
+    byte b() default 1;
+    short c() default 1;
+    double d() default 1;
+    float e() default 1;
+    long j() default 1;
+    String f() default "default";
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@JavaAnn class MyClass
+@JavaAnn2 class MyClass2
+
+fun box(): String {
+    val ann = MyClass::class.java.getAnnotation(JavaAnn::class.java)
+    if (ann == null) return "fail: cannot find Ann on MyClass}"
+    if (ann.value != "default") return "fail: annotation parameter i should be 'default', but was ${ann.value}"
+
+    val ann2 = MyClass2::class.java.getAnnotation(JavaAnn2::class.java)
+    if (ann2 == null) return "fail: cannot find Ann on MyClass}"
+    if (ann2.a != 1) return "fail for a: expected = 1, but was ${ann2.a}"
+    if (ann2.b != 1.toByte()) return "fail for b: expected = 1, but was ${ann2.b}"
+    if (ann2.c != 1.toShort()) return "fail for c: expected = 1, but was ${ann2.c}"
+    if (ann2.d != 1.0) return "fail for d: expected = 1, but was ${ann2.d}"
+    if (ann2.e != 1F) return "fail for e: expected = 1, but was ${ann2.e}"
+    if (ann2.j != 1L) return "fail for j: expected = 1, but was ${ann2.j}"
+    if (ann2.f != "default") return "fail for f: expected = default, but was ${ann2.f}"
+
+    return "OK"
+}

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

@@ -0,0 +1,41 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Foo.java
+
+class Foo {
+    public static final int i = -2;
+    public static final short s = -2;
+    public static final float f = -2f;
+    public static final double d = -2.0;
+    public static final long l = -2L;
+    public static final byte b = -2;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b) class MyClass
+
+fun box(): String {
+    val ann = MyClass::class.java.getAnnotation(Ann::class.java)
+    if (ann == null) return "fail: cannot find Ann on MyClass}"
+    if (ann.i != -2) return "fail: annotation parameter i should be -2, but was ${ann.i}"
+    if (ann.s != (-2).toShort()) return "fail: annotation parameter i should be -2, but was ${ann.i}"
+    if (ann.f != -2.toFloat()) return "fail: annotation parameter i should be -2, but was ${ann.i}"
+    if (ann.d != -2.toDouble()) return "fail: annotation parameter i should be -2, but was ${ann.i}"
+    if (ann.l != -2.toLong()) return "fail: annotation parameter i should be -2, but was ${ann.i}"
+    if (ann.b != (-2).toByte()) return "fail: annotation parameter i should be -2, but was ${ann.i}"
+    return "OK"
+}
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Ann(
+        val i: Int,
+        val s: Short,
+        val f: Float,
+        val d: Double,
+        val l: Long,
+        val b: Byte
+)

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

@@ -0,0 +1,56 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Foo.java
+
+class Foo {
+    public static final int i = 2;
+    public static final short s = 2;
+    public static final float f = 2f;
+    public static final double d = 2.0;
+    public static final long l = 2L;
+    public static final byte b = 2;
+    public static final boolean bool = true;
+    public static final char c = 'c';
+    public static final String str = "str";
+    public static final int charAsInt = '3';
+    public static final char intAsChar = 3;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b, Foo.bool, Foo.c, Foo.str, Foo.charAsInt, Foo.intAsChar) class MyClass
+
+fun box(): String {
+    val ann = MyClass::class.java.getAnnotation(Ann::class.java)
+    if (ann == null) return "fail: cannot find Ann on MyClass"
+    if (ann.i != 2) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.s != 2.toShort()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.f != 2.toFloat()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.d != 2.toDouble()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.l != 2.toLong()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.b != 2.toByte()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (!ann.bool) return "fail: annotation parameter i should be true, but was ${ann.i}"
+    if (ann.c != 'c') return "fail: annotation parameter i should be c, but was ${ann.i}"
+    if (ann.str != "str") return "fail: annotation parameter i should be str, but was ${ann.i}"
+    if (ann.i2 != '3'.toInt()) return "fail: annotation parameter i2 should be ${'3'.toInt()}, but was ${ann.i}"
+    if (ann.c2 != 3.toChar()) return "fail: annotation parameter c2 should be 3, but was ${ann.i}"
+    return "OK"
+}
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Ann(
+        val i: Int,
+        val s: Short,
+        val f: Float,
+        val d: Double,
+        val l: Long,
+        val b: Byte,
+        val bool: Boolean,
+        val c: Char,
+        val str: String,
+        val i2: Int,
+        val c2: Char
+)

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

@@ -0,0 +1,44 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Foo.java
+
+class Foo {
+    public static final int i = 2;
+    public static final short s = 2;
+    public static final float f = 2;
+    public static final double d = 2;
+    public static final long l = 2;
+    public static final byte b = 2;
+    public static final char c = 99;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@Ann(Foo.i, Foo.s, Foo.f, Foo.d, Foo.l, Foo.b, Foo.c) class MyClass
+
+fun box(): String {
+    val ann = MyClass::class.java.getAnnotation(Ann::class.java)
+    if (ann == null) return "fail: cannot find Ann on MyClass"
+    if (ann.i != 2) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.s != 2.toShort()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.f != 2.toFloat()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.d != 2.toDouble()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.l != 2.toLong()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.b != 2.toByte()) return "fail: annotation parameter i should be 2, but was ${ann.i}"
+    if (ann.c != 'c') return "fail: annotation parameter i should be c, but was ${ann.i}"
+    return "OK"
+}
+
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Ann(
+        val i: Int,
+        val s: Short,
+        val f: Float,
+        val d: Double,
+        val l: Long,
+        val b: Byte,
+        val c: Char
+)

compiler/testData/codegen/box/annotations/kClassMapping/arrayClassParameter.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    Class<?>[] args();
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class O
+class K
+
+@JavaAnn(args = arrayOf(O::class, K::class)) class MyClass
+
+fun box(): String {
+    val args = MyClass::class.java.getAnnotation(JavaAnn::class.java).args
+    val argName1 = args[0].java.simpleName ?: "fail 1"
+    val argName2 = args[1].java.simpleName ?: "fail 2"
+    return argName1 + argName2
+}

compiler/testData/codegen/box/annotations/kClassMapping/arrayClassParameterOnJavaClass.kt

@@ -0,0 +1,31 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    Class<?>[] args();
+}
+
+// FILE: MyJavaClass.java
+
+class O {}
+class K {}
+
+@JavaAnn(args = {O.class, K.class})
+class MyJavaClass {}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val args = MyJavaClass::class.java.getAnnotation(JavaAnn::class.java).args
+    val argName1 = args[0].java.simpleName ?: "fail 1"
+    val argName2 = args[1].java.simpleName ?: "fail 2"
+    return argName1 + argName2
+}

compiler/testData/codegen/box/annotations/kClassMapping/classParameter.kt

@@ -0,0 +1,26 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    Class<?> value();
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class OK
+
+@JavaAnn(OK::class) class MyClass
+
+fun box(): String {
+    val ann = MyClass::class.java.getAnnotation(JavaAnn::class.java)
+    if (ann == null) return "fail: cannot find JavaAnn on MyClass"
+    return ann.value.java.simpleName!!
+}

compiler/testData/codegen/box/annotations/kClassMapping/classParameterOnJavaClass.kt

@@ -0,0 +1,29 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    Class<?> value();
+}
+
+// FILE: MyJavaClass.java
+
+class OK {}
+
+@JavaAnn(OK.class)
+class MyJavaClass {}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val ann = MyJavaClass::class.java.getAnnotation(JavaAnn::class.java)
+    if (ann == null) return "fail: cannot find JavaAnn on MyClass"
+    return ann.value.java.simpleName!!
+}

compiler/testData/codegen/box/annotations/kClassMapping/varargClassParameter.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    Class<?>[] value();
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class O
+class K
+
+@JavaAnn(O::class, K::class) class MyClass
+
+fun box(): String {
+    val args = MyClass::class.java.getAnnotation(JavaAnn::class.java).value
+    val argName1 = args[0].java.simpleName ?: "fail 1"
+    val argName2 = args[1].java.simpleName ?: "fail 2"
+    return argName1 + argName2
+}

compiler/testData/codegen/box/annotations/kClassMapping/varargClassParameterOnJavaClass.kt

@@ -0,0 +1,34 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaAnn.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnn {
+    Class<?>[] value();
+}
+
+class O {}
+class K {}
+
+// FILE: MyJavaClass.java
+
+@JavaAnn({O.class, K.class})
+class MyJavaClass {}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class O
+class K
+
+fun box(): String {
+    val args = MyJavaClass::class.java.getAnnotation(JavaAnn::class.java).value
+    val argName1 = args[0].java.simpleName ?: "fail 1"
+    val argName2 = args[1].java.simpleName ?: "fail 2"
+    return argName1 + argName2
+}

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

@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.CLASS)
+@interface Foo {
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+@Foo class Bar
+
+fun box(): String {
+    Bar()
+    return "OK"
+}

compiler/testData/codegen/box/annotations/typeAnnotations/implicitReturnAgainstCompiled.kt

@@ -0,0 +1,78 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+// FULL_JDK
+
+// MODULE: lib
+// FILE: ImplicitReturn.java
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+public class ImplicitReturn {
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.TYPE_USE)
+    public @ interface TypeAnn {}
+
+    @ImplicitReturn.TypeAnn
+    public String bar() {
+        return "OK";
+    }
+}
+
+
+// MODULE: main(lib)
+// FILE: Kotlin.kt
+
+import java.lang.reflect.AnnotatedType
+import kotlin.reflect.jvm.javaMethod
+import kotlin.reflect.jvm.javaField
+import kotlin.test.fail
+
+class Kotlin {
+
+    fun foo() = ImplicitReturn().bar()
+
+    @JvmField
+    val field = ImplicitReturn().bar()
+}
+
+fun box(): String {
+
+    checkTypeAnnotation(
+        Kotlin::foo.javaMethod!!.annotatedReturnType,
+        "class java.lang.String",
+        "@ImplicitReturn\$TypeAnn()",
+        "foo"
+    )
+
+    checkTypeAnnotation(
+        Kotlin::field.javaField!!.annotatedType,
+        "class java.lang.String",
+        "@ImplicitReturn\$TypeAnn()",
+        "foo"
+    )
+
+    return Kotlin().foo()
+}
+
+fun checkTypeAnnotation(
+    annotatedType: AnnotatedType,
+    type: String,
+    annotations: String,
+    message: String
+) {
+    if (annotatedType.annotation() != annotations) fail("check $message (1): ${annotatedType.annotation()} != $annotations")
+
+    if (annotatedType.type.toString() != type) fail("check $message (2): ${annotatedType.type} != $type")
+}
+
+
+fun AnnotatedType.annotation() = annotations.joinToString()

compiler/testData/codegen/box/callableReference/constructor.kt

@@ -0,0 +1,15 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: A.java
+
+class A {
+    public A(double x, int y) { }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    (::A)(0.0, 0)
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/kt16412.kt

@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: MFunction.java
+
+public interface MFunction<T, R> {
+    R invoke(T t);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+
+object Foo {
+    class Requester(val dealToBeOffered: String)
+}
+
+class Bar {
+    val foo = MFunction(Foo::Requester)
+}
+
+fun box(): String {
+    return Bar().foo("OK").dealToBeOffered
+}

compiler/testData/codegen/box/callableReference/publicFinalField.kt

@@ -0,0 +1,12 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: A.java
+
+public class A {
+    public final String field = "OK";
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box() = (A::field).get(A())

compiler/testData/codegen/box/callableReference/publicMutableField.kt

@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: A.java
+
+public class A {
+    public int field = 239;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val a = A()
+    val f = A::field
+    if (f.get(a) != 239) return "Fail 1: ${f.get(a)}"
+    f.set(a, 42)
+    if (f.get(a) != 42) return "Fail 2: ${f.get(a)}"
+    if (f.get(a) != 42) return "Fail 2: ${f.get(a)}"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/staticMethod.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: A.java
+
+class A {
+    public static void main(String[] args) {
+        args[0] = "OK";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val args = arrayOf("Fail")
+    (A::main)(args)
+    return args[0]
+}

compiler/testData/codegen/box/constructor/genericConstructor.kt

@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/Foo.java
+
+package test;
+
+public class Foo<T extends Number> {
+    public Foo(T number) {}
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.Foo
+
+class Subclass : Foo<Int>(42) {
+}
+
+fun box(): String {
+    Subclass()
+    return "OK"
+}

compiler/testData/codegen/box/constructor/secondaryConstructor.kt

@@ -0,0 +1,51 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/Foo.java
+
+package test;
+
+public class Foo {
+    private final String x;
+    private final String y;
+
+    public Foo(String x, String y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Foo(String x) {
+        this(x, "def_y");
+    }
+
+    public Foo() {
+        this("def_x");
+    }
+
+    @Override
+    public String toString() {
+        return x + "#" + y;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.Foo;
+
+class Child : Foo {
+    constructor(): super() {}
+    constructor(x: String): super(x) {}
+    constructor(x: String, y: String): super(x, y) {}
+}
+
+fun box(): String {
+    val c1 = Child().toString()
+    if (c1 != "def_x#def_y") return "fail1: $c1"
+
+    val c2 = Child("abc").toString()
+    if (c2 != "abc#def_y") return "fail2: $c2"
+
+    val c3 = Child("abc", "def").toString()
+    if (c3 != "abc#def") return "fail3: $c3"
+    return "OK"
+}

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

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+import java.util.Set;
+
+public class Foo {
+    public interface A extends Set<String> {}
+
+    public interface B extends Set<String> {}
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import Foo.*
+import java.util.HashSet
+
+class Impl(b: B): A, B by b
+
+fun box() = "OK"

compiler/testData/codegen/box/enum/nameConflict.kt

@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: C.java
+public enum C {
+    OK(0);
+
+    private final int ordinal;
+
+    C(int ordinal) { this.ordinal = ordinal; }
+
+    public int getOrdinal() { return ordinal; }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+fun box(): String {
+    val ok = C.OK
+    return when (ok) {
+        C.OK -> "OK"
+        else -> "fail"
+    }
+}

compiler/testData/codegen/box/enum/simpleJavaEnum.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/En.java
+
+package test;
+
+public enum En {
+    A;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.*
+
+fun box() =
+    if (En.A.toString() == "A") "OK"
+    else "fail"

compiler/testData/codegen/box/enum/simpleJavaEnumWithFunction.kt

@@ -0,0 +1,31 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/En.java
+
+package test;
+
+import java.lang.Override;
+import java.lang.String;
+
+public enum En {
+    A {
+        @Override
+        public String repr() {
+            return "A";
+        }
+    },
+    B;
+    
+    public String repr() {
+        return "ololol" + toString();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.En.*
+
+fun box() =
+    if (A.repr() == "A" && B.repr() == "olololB") "OK"
+    else "fail"

compiler/testData/codegen/box/enum/simpleJavaEnumWithStaticImport.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/En.java
+
+package test;
+
+public enum En {
+    A;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.En.A
+
+fun box() =
+    if (A.toString() == "A") "OK"
+    else "fail"

compiler/testData/codegen/box/enum/simpleJavaInnerEnum.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/Foo.java
+
+package test;
+
+public class Foo {
+    public enum MyEnum {
+        A;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.*
+import test.Foo.MyEnum.A
+
+fun box() =
+    if (Foo.MyEnum.A.toString() == "A" && A.toString() == "A") "OK"
+    else "fail"

compiler/testData/codegen/box/enum/staticField.kt

@@ -0,0 +1,32 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/E.java
+
+package test;
+
+import java.util.Set;
+import java.util.EnumSet;
+
+public enum E {
+    INSTANCE;
+    
+    public static int foo = 42;
+    
+    public static final Set<E> INSTANCES = EnumSet.of(INSTANCE);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.E
+
+fun box(): String {
+    val instances = E.INSTANCES
+    if (E.foo != 42)
+        return "Wrong foo ${E.foo}"
+    if (instances.size != 1)
+        return "Wrong size ${instances.size}"
+    if (E.INSTANCES.iterator().next() != E.INSTANCE)
+        return "Wrong instance ${E.INSTANCES.iterator().next()}"
+    return "OK"
+}

compiler/testData/codegen/box/enum/staticMethod.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/En.java
+
+package test;
+
+public enum En {
+    ENTRY;
+    
+    public static String foo() {
+        return "OK";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box() = test.En.foo()

compiler/testData/codegen/box/functions/constructor.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: A.java
+
+class A {
+    public A() {}
+
+    public A(String x) {}
+
+    public A(long l, double z) {}
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    A()
+    A("")
+    A(0.toLong(), 0.0)
+    return "OK"
+}

compiler/testData/codegen/box/functions/max.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+import java.util.*;
+
+public class Foo {
+    public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
+        return Collections.max(coll);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    return Foo.max(java.util.Arrays.asList("AK", "OK", "EK"))!!
+}

compiler/testData/codegen/box/functions/referencesStaticInnerClassMethod.kt

@@ -0,0 +1,15 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: R.java
+
+class R {
+    public static class id {
+        public static final int main = 17;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box() =
+    if (R.id.main == 17) "OK" else "fail"

compiler/testData/codegen/box/functions/referencesStaticInnerClassMethodL2.kt

@@ -0,0 +1,17 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: R.java
+
+class R {
+    public static class id {
+        public static class zzz {
+            public static final int main = 17;
+        }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box() =
+    if (R.id.zzz.main == 17) "OK" else "fail"

compiler/testData/codegen/box/functions/unrelatedUpperBounds.kt

@@ -0,0 +1,18 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+import java.util.Collection;
+
+public class Foo {
+    public static <T extends CharSequence & java.io.Serializable> T id(T p) {
+        return p;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    return Foo.id("OK" as java.lang.String)!! as kotlin.String
+}

compiler/testData/codegen/box/ieee754/anyToReal_AgainstCompiled.kt

@@ -0,0 +1,30 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Object minus0()
+    {
+        return -0.0;
+    }
+
+    public Object plus0()
+    {
+        return 0.0;
+    }
+
+}
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass()
+
+    if ((jClass.minus0() as Double) < (jClass.plus0() as Double)) return "fail 1"
+
+    if ((jClass.minus0() as Double) != (jClass.plus0() as Double)) return "fail 2"
+
+    return "OK"
+}

compiler/testData/codegen/box/ieee754/comparableTypeCast_AgainstCompiled.kt

@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Double minus0()
+    {
+        return -0.0;
+    }
+
+    public Double plus0()
+    {
+        return 0.0;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass()
+
+    if ((jClass.minus0() as Comparable<Double>) >= jClass.plus0()) return "fail 1"
+    if ((jClass.minus0() as Comparable<Double>) == jClass.plus0()) return "fail 2"
+    if (jClass.minus0() == (jClass.plus0() as Comparable<Double>)) return "fail 3"
+
+    return "OK"
+}

compiler/testData/codegen/box/ieee754/double.kt

@@ -0,0 +1,52 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Double minus0(){
+        return -0.0;
+    }
+
+    public Double plus0(){
+        return 0.0;
+    }
+
+    public Double null0(){
+        return null;
+    }
+
+}
+
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass()
+
+    if (jClass.minus0() < jClass.plus0()) return "fail 1"
+
+    //TODO: KT-14989
+    //if (jClass.null0() < jClass.plus0()) return "fail 2"
+
+
+    if (jClass.plus0() > jClass.minus0()) return "fail 3"
+
+    //TODO: KT-14989
+    //if (jClass.null0() < jClass.plus0()) return "fail 4"
+
+    if (jClass.minus0() != jClass.plus0()) return "fail 5"
+
+    var value = jClass.minus0() == jClass.plus0()
+    if (!value) return "fail 6"
+
+    if (jClass.null0() == jClass.plus0()) return "fail 7"
+    if (jClass.plus0() == jClass.null0()) return "fail 8"
+
+    value = jClass.null0() == jClass.null0()
+    if (!value) return "fail 9"
+
+    return "OK"
+}
+

compiler/testData/codegen/box/ieee754/explicitCompareCall_AgainstCompiled.kt

@@ -0,0 +1,41 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Double minus0(){
+        return -0.0;
+    }
+
+    public Double plus0(){
+        return 0.0;
+    }
+
+    public Double null0(){
+        return null;
+    }
+
+}
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+
+fun box(): String {
+
+    val jClass = JavaClass()
+
+    if (jClass.minus0().compareTo(jClass.plus0()) != -1) return "fail 1"
+
+    //TODO: KT-14989
+    //if (jClass.null0().compareTo(jClass.plus0())) return "fail 2"
+    try {
+        if (jClass.minus0().compareTo(jClass.null0()) != -2) return "fail 3"
+        return "fail: exception expected";
+    } catch (e: NullPointerException) {
+
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ieee754/explicitEqualsCall_AgainstCompiled.kt

@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Double minus0(){
+        return -0.0;
+    }
+
+    public Double plus0(){
+        return 0.0;
+    }
+
+}
+
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass()
+
+    if (jClass.minus0().equals(jClass.plus0())) return "fail 1"
+    if (jClass.plus0().equals(jClass.minus0())) return "fail 2"
+
+    return "OK"
+}
+

compiler/testData/codegen/box/ieee754/float.kt

@@ -0,0 +1,55 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Float minus0()
+    {
+        return -0.0F;
+    }
+
+    public Float plus0()
+    {
+        return 0.0F;
+    }
+
+    public Float null0()
+    {
+        return null;
+    }
+
+}
+
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass()
+
+    if (jClass.minus0() < jClass.plus0()) return "fail 1"
+
+    //TODO: KT-14989
+    //if (jClass.null0() < jClass.plus0()) return "fail 2"
+
+    if (jClass.plus0() > jClass.minus0()) return "fail 3"
+
+    //TODO: KT-14989
+    //if (jClass.null0() < jClass.plus0()) return "fail 4"
+
+
+    if (jClass.minus0() != jClass.plus0()) return "fail 5"
+
+    var value = jClass.minus0() == jClass.plus0()
+    if (!value) return "fail 6"
+
+    if (jClass.null0() == jClass.plus0()) return "fail 7"
+    if (jClass.plus0() == jClass.null0()) return "fail 8"
+
+    value = jClass.null0() == jClass.null0()
+    if (!value) return "fail 9"
+
+    return "OK"
+}
+

compiler/testData/codegen/box/ieee754/generic_AgainstCompiled.kt

@@ -0,0 +1,39 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass<T> {
+
+    private T minus0;
+
+    private T plus0;
+
+    JavaClass(T minus0, T plus0)
+    {
+        this.minus0 = minus0;
+        this.plus0 = plus0;
+    }
+
+    public T minus0()
+    {
+        return minus0;
+    }
+
+    public T plus0()
+    {
+        return plus0;
+    }
+
+}
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass<Double>(-0.0, 0.0)
+
+    if (jClass.minus0() < jClass.plus0()) return "fail 2"
+    if (jClass.minus0() != jClass.plus0()) return "fail 5"
+
+    return "OK"
+}

compiler/testData/codegen/box/ieee754/nullableAnyToReal_AgainstCompiled.kt

@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Object minus0()
+    {
+        return -0.0;
+    }
+
+    public Object plus0()
+    {
+        return 0.0;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+
+    val jClass = JavaClass()
+
+    if ((jClass.minus0() as Double) < (jClass.plus0() as Double)) return "fail 2"
+    if ((jClass.minus0() as Double) != (jClass.plus0() as Double)) return "fail 5"
+
+    return "OK"
+}

compiler/testData/codegen/box/inline/kt19910.kt

@@ -0,0 +1,41 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// FULL_JDK
+// WITH_RUNTIME
+// TARGET_BACKEND: JVM
+
+// MODULE: lib
+// FILE: J.java
+public class J {
+    public interface Consumer {
+        void accept(String p);
+    }
+
+    public static void invokeWithNull(Consumer x) {
+        x.accept(null);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: Kotlin.kt
+inline fun makeRunnable(crossinline lambda: () -> Unit) =
+        object : Runnable {
+            override fun run() {
+                lambda()
+            }
+        }
+
+fun box(): String {
+    try {
+        makeRunnable {
+            J.invokeWithNull(object : J.Consumer {
+                override fun accept(t: String) {
+                    println(t)
+                }
+            })
+        }.run()
+    } catch (e: NullPointerException) {
+        return "OK"
+    }
+
+    return "fail: exception expected"
+}

compiler/testData/codegen/box/innerClass/kt3532.kt

@@ -0,0 +1,15 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+public class Foo {
+    public class Inner { }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    Foo().Inner()
+    return "OK"
+}

compiler/testData/codegen/box/innerClass/kt3812.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+public class Foo {
+    public class Inner {
+
+    }
+
+    public class Inner$ {
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    Foo().Inner()
+    Foo().`Inner$`()
+    return "OK"
+}

compiler/testData/codegen/box/innerClass/kt4036.kt

@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+public class Foo {
+    public class Inner1$class {
+    }
+
+    public class Inner2$class {
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    Foo().`Inner1$class`()
+    Foo().`Inner2$class`()
+    return "OK"
+}

compiler/testData/codegen/box/interfaces/defaultMethod.kt

@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// JVM_TARGET: 1.8
+
+// MODULE: lib
+// FILE: A.java
+
+public interface A {
+    default String getMessage() {
+        return "OK";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+interface I : A
+
+class B : A
+
+open class C(a : A) : I, A by a
+
+fun box(): String {
+    val a = B()
+    return C(a).message
+}

compiler/testData/codegen/box/interfaces/inheritJavaInterface.kt

@@ -0,0 +1,27 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: A.java
+
+interface A {
+    void foo();
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal interface B : A {
+    fun bar() = 1
+}
+
+internal interface C : B
+
+internal class D : C {
+    override fun foo() {}
+}
+
+fun box(): String {
+    val d = D()
+    d.foo()
+    d.bar()
+    return "OK"
+}

compiler/testData/codegen/box/multiplatform/annotationsViaActualTypeAliasFromBinary.kt

@@ -0,0 +1,96 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// !LANGUAGE: +MultiPlatformProjects
+// WITH_REFLECT
+
+// MODULE: lib
+// FILE: Jnno.java
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Jnno {
+    byte b() default 1;
+    char c() default 'x';
+    double d() default 3.14;
+    float f() default -2.72f;
+    int i() default 42424242;
+    int i2() default 21212121 + 32323232;
+    long j() default 239239239239239L;
+    long j2() default 239239;
+    short s() default 42;
+    boolean z() default true;
+    byte[] ba() default {-1};
+    char[] ca() default {'y'};
+    double[] da() default {-3.14159};
+    float[] fa() default {2.7218f};
+    int[] ia() default {424242};
+    long[] ja() default {239239239239L, 239239};
+    short[] sa() default {-43};
+    boolean[] za() default {false, true};
+    String str() default "fi" + "zz";
+    Class<?> k() default Number.class;
+    // E e() default E.E1;
+    // TODO: A a() default @A("1");
+    String[] stra() default {"bu", "zz"};
+    Class<?>[] ka() default {double.class, String.class, long[].class, Integer[][][].class, void.class};
+    // E[] ea() default {E.E2, E.E3};
+    // TODO: A[] aa() default {@A("2"), @A("3")};
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+// See compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias2.kt
+
+// This test checks the same behavior but against the Java implementation compiled to the .class file (as opposed to a .java source file).
+// Enum annotation argument is commented below, because to be able to resolve E in Jnno.java we have to have a multi-module test where
+// one of the modules also contains Java files, and that is too complicated for our test infrastructure at the moment.
+
+import kotlin.reflect.KClass
+
+expect annotation class Anno(
+    val b: Byte = 1.toByte(),
+    val c: Char = 'x',
+    val d: Double = 3.14,
+    val f: Float = -2.72f,
+    val i: Int = 42424242,
+    val i2: Int = 53535353,
+    val j: Long = 239239239239239L,
+    val j2: Long = 239239L,
+    val s: Short = 42.toShort(),
+    val z: Boolean = true,
+    val ba: ByteArray = [(-1).toByte()],
+    val ca: CharArray = ['y'],
+    val da: DoubleArray = [-3.14159],
+    val fa: FloatArray = [2.7218f],
+    val ia: IntArray = [424242],
+    val ja: LongArray = [239239239239L, 239239L],
+    val sa: ShortArray = [(-43).toShort()],
+    val za: BooleanArray = [false, true],
+    val str: String = "fizz",
+    val k: KClass<*> = Number::class,
+    // val e: E = E.E1,
+    // TODO: val a: A = A("1"),
+    val stra: Array<String> = ["bu", "zz"],
+    val ka: Array<KClass<*>> = [Double::class, String::class, LongArray::class, Array<Array<Array<Int>>>::class, Unit::class]
+    // val ea: Array<E> = [E.E2, E.E3],
+    // TODO: val aa: Array<A> = [A("2"), A("3")]
+)
+
+// enum class E { E1, E2, E3 }
+
+annotation class A(val value: String)
+
+@Anno
+fun test() {}
+
+actual typealias Anno = Jnno
+
+fun box(): String {
+    // We don't need to check the contents, just check that there are no anomalities in the bytecode by loading annotations
+    ::test.annotations.toString()
+
+    return "OK"
+}

compiler/testData/codegen/box/notNullAssertions/callAssertions.kt

@@ -0,0 +1,129 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.DISABLE_PARAM_ASSERTIONS
+
+// MODULE: lib
+// FILE: A.java
+
+import org.jetbrains.annotations.NotNull;
+
+public class A {
+    @NotNull
+    public final String NULL = null;
+
+    @NotNull
+    public static final String STATIC_NULL = null;
+
+    public String foo() {
+        return null;
+    }
+
+    public static String staticFoo() {
+        return null;
+    }
+
+    public A plus(A a) {
+        return null;
+    }
+
+    public A inc() {
+        return null;
+    }
+
+    public Object get(Object o) {
+        return null;
+    }
+
+    public A a() { return this; }
+
+    public static class B {
+        public static B b() { return null; }
+    }
+
+    public static class C {
+        public static C c() { return null; }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: callAssertions.kt
+
+class AssertionChecker(val nullPointerExceptionExpected: Boolean) {
+    operator fun invoke(name: String, f: () -> Any) {
+        try {
+            f()
+        } catch (e: NullPointerException) {
+            if (!nullPointerExceptionExpected) throw AssertionError("Unexpected NullPointerException on calling $name")
+            return
+        }
+        if (nullPointerExceptionExpected) throw AssertionError("NullPointerException expected on calling $name")
+    }
+}
+
+
+interface Tr {
+    fun foo(): String
+}
+
+class Derived : A(), Tr {
+    override fun foo() = super<A>.foo()
+}
+
+class Delegated : Tr by Derived() {
+}
+
+fun checkAssertions(illegalStateExpected: Boolean) {
+    val check = AssertionChecker(illegalStateExpected)
+
+    // simple call
+    check("foo") { A().foo() }
+
+    // simple static call
+    check("staticFoo") { A.staticFoo() }
+
+    // supercall
+    check("foo") { Derived().foo() }
+
+    // delegated call
+    check("foo") { Delegated().foo() }
+
+    // collection element
+    check("get") { A()[""] }
+
+    // binary expression
+    check("plus") { A() + A() }
+
+    // field
+    check("NULL") { A().NULL }
+
+    // static field
+    check("STATIC_NULL") { A.STATIC_NULL }
+
+    // postfix expression
+    // TODO:
+//    check("inc") { var a = A().a(); a++ }
+
+    // prefix expression
+    check("inc-b") { var a = A.B.b(); a++ }
+
+    // prefix expression
+    check("inc-c") { var a = A.C.c(); a++ }
+
+    // prefix expression
+    check("inc") { var a = A().a(); ++a }
+
+    // prefix expression
+    check("inc-b") { var a = A.B.b(); ++a }
+
+    // prefix expression
+    // TODO:
+//    check("inc-c") { var a = A.C.c(); ++a }
+}
+
+operator fun A.C.inc(): A.C = A.C()
+operator fun <T> T.inc(): T = null as T
+
+fun box(): String {
+    checkAssertions(true)
+    return "OK"
+}

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

@@ -0,0 +1,36 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+
+// MODULE: lib
+// FILE: Delegation.java
+
+public class Delegation {
+    public static class ReturnNull {
+        public String foo() {
+            return null;
+        }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: delegation.kt
+
+interface Tr {
+    fun foo(): String
+}
+
+class DelegateTo : Delegation.ReturnNull(), Tr {
+    override fun foo() = super<Delegation.ReturnNull>.foo()
+}
+
+class DelegateFrom : Tr by DelegateTo()
+
+fun box(): String {
+    try {
+        DelegateFrom().foo()
+        return "Fail: should have been an exception"
+    }
+    catch(e: NullPointerException) {
+        return "OK"
+    }
+}

compiler/testData/codegen/box/notNullAssertions/doGenerateParamAssertions.kt

@@ -0,0 +1,39 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.DISABLE_CALL_ASSERTIONS
+// MODULE: lib
+// FILE: C.java
+package test;
+
+import org.jetbrains.annotations.NotNull;
+
+public abstract class C<Type> {
+
+    public abstract void doTest(@NotNull Type s);
+
+    public static void runTest(C a) {
+        try {
+            a.doTest(null);
+        } catch (NullPointerException e) {
+            return;
+        }
+        throw new AssertionError("Fail: NullPointerException expected");
+    }
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+import test.C
+
+class TestString : C<String>() {
+    override fun doTest(s: String) { }
+}
+
+class TestUnit : C<Unit>() {
+    override fun doTest(s: Unit) { }
+}
+
+fun box(): String {
+    C.runTest(TestString())
+    C.runTest(TestUnit())
+    return "OK"
+}

compiler/testData/codegen/box/notNullAssertions/noCallAssertions.kt

@@ -0,0 +1,128 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.DISABLE_PARAM_ASSERTIONS, +JVM.DISABLE_CALL_ASSERTIONS
+
+// MODULE: lib
+// FILE: A.java
+
+import org.jetbrains.annotations.NotNull;
+
+public class A {
+    @NotNull
+    public final String NULL = null;
+
+    @NotNull
+    public static final String STATIC_NULL = null;
+
+    public String foo() {
+        return null;
+    }
+
+    public static String staticFoo() {
+        return null;
+    }
+
+    public A plus(A a) {
+        return null;
+    }
+
+    public A inc() {
+        return null;
+    }
+
+    public Object get(Object o) {
+        return null;
+    }
+
+    public A a() { return this; }
+
+    public static class B {
+        public static B b() { return null; }
+    }
+
+    public static class C {
+        public static C c() { return null; }
+    }
+}
+
+// MODULE: main(lib)
+// FILE: noCallAssertions.kt
+
+class AssertionChecker(val nullPointerExceptionExpected: Boolean) {
+    operator fun invoke(name: String, f: () -> Any) {
+        try {
+            f()
+        } catch (e: NullPointerException) {
+            if (!nullPointerExceptionExpected) throw AssertionError("Unexpected NullPointerException on calling $name")
+            return
+        }
+        if (nullPointerExceptionExpected) throw AssertionError("NullPointerException expected on calling $name")
+    }
+}
+
+
+interface Tr {
+    fun foo(): String
+}
+
+class Derived : A(), Tr {
+    override fun foo() = super<A>.foo()
+}
+
+class Delegated : Tr by Derived() {
+}
+
+fun checkAssertions(nullPointerExceptionExpected: Boolean) {
+    val check = AssertionChecker(nullPointerExceptionExpected)
+
+    // simple call
+    check("foo") { A().foo() }
+
+    // simple static call
+    check("staticFoo") { A.staticFoo() }
+
+    // supercall
+    check("foo") { Derived().foo() }
+
+    // delegated call
+    check("foo") { Delegated().foo() }
+
+    // collection element
+    check("get") { A()[""] }
+
+    // binary expression
+    check("plus") { A() + A() }
+
+    // field
+    check("NULL") { A().NULL }
+
+    // static field
+    check("STATIC_NULL") { A.STATIC_NULL }
+
+    // postfix expression
+    // TODO:
+//    check("inc") { var a = A().a(); a++ }
+
+    // prefix expression
+    check("inc-b") { var a = A.B.b(); a++ }
+
+    // prefix expression
+    check("inc-c") { var a = A.C.c(); a++ }
+
+    // prefix expression
+    check("inc") { var a = A().a(); ++a }
+
+    // prefix expression
+    check("inc-b") { var a = A.B.b(); ++a }
+
+    // prefix expression
+    // TODO:
+//    check("inc-c") { var a = A.C.c(); ++a }
+}
+
+operator fun A.C.inc(): A.C = A.C()
+operator fun <T> T.inc(): T = null as T
+
+fun box(): String {
+    checkAssertions(false)
+    return "OK"
+}

compiler/testData/codegen/box/notNullAssertions/rightElvisOperand.kt

@@ -0,0 +1,35 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// MODULE: lib
+// FILE: RightElvisOperand.java
+
+class RightElvisOperand {
+    static String foo() {
+        return null;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun baz(): String? = null
+
+fun bar(): String = baz() ?: RightElvisOperand.foo()
+
+fun foo(x: String) {}
+
+fun box(): String {
+    try {
+        foo(baz() ?: RightElvisOperand.foo())
+        return "Fail: should have been an exception in `foo(baz() ?: RightElvisOperand.foo())`"
+    }
+    catch(e: NullPointerException) {}
+
+    try {
+        bar()
+        return "Fail: should have been an exception in `bar()`"
+    }
+    catch(e: NullPointerException) {
+        return "OK"
+    }
+}

compiler/testData/codegen/box/oldLanguageVersions/ieee754/explicitEqualsCallNull.kt

@@ -0,0 +1,34 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// !LANGUAGE: -ThrowNpeOnExplicitEqualsForBoxedNull
+// IGNORE_BACKEND: JVM_IR
+// ^ ThrowNpeOnExplicitEqualsForBoxedNull is introduced in 1.2.
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Double minus0(){
+        return -0.0;
+    }
+
+    public Double plus0(){
+        return 0.0;
+    }
+
+    public Double null0(){
+        return null;
+    }
+
+}
+
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun box(): String {
+    val jClass = JavaClass()
+
+    if (jClass.null0().equals(jClass.plus0())) return "fail 6"
+    if (jClass.minus0().equals(jClass.null0())) return "fail 7"
+    return "OK"
+}

compiler/testData/codegen/box/platformTypes/genericUnit.kt

@@ -0,0 +1,36 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Foo.java
+
+public class Foo {
+    public static class Key<T> {}
+
+    public static <T> T getNull(Key<T> key) {
+        return null;
+    }
+
+    public static <T> T get(Key<T> key, T t) {
+        return t;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import Foo.*
+
+val key = Key<Unit>()
+
+fun box(): String {
+    val n1 = getNull(key)
+    if (n1 != null) return "Fail 1: $n1"
+
+    val n2 = get(key, null)
+    if (n2 != null) return "Fail 2: $n2"
+
+    val n3 = get(key, Unit)
+    if (n3 == null) return "Fail 3.0: $n3"
+    if (n3 != Unit) return "Fail 3.1: $n3"
+
+    return "OK"
+}

compiler/testData/codegen/box/platformTypes/kt14989.kt

@@ -0,0 +1,29 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+//WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public Double test() {
+        return null;
+    }
+
+}
+
+// MODULE: main(lib)
+// FILE: b.kt
+
+fun test(s: Double) {
+
+}
+
+fun box(): String {
+    try {
+        test(JavaClass().test())
+    }
+    catch (e: NullPointerException) {
+        return "OK"
+    }
+    return "fail"
+}

compiler/testData/codegen/box/platformTypes/specializedMapFull.kt

@@ -0,0 +1,123 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// MODULE: lib
+// FILE: AbstractSpecializedMap.java
+public abstract class AbstractSpecializedMap implements java.util.Map<Integer, Double> {
+    public abstract double put(int x, double y);
+    public abstract double remove(int k);
+    public abstract double get(int k);
+
+    public abstract boolean containsKey(int k);
+    public boolean containsKey(Object x) {
+        return false;
+    }
+
+    public abstract boolean containsValue(double v);
+    public boolean containsValue(Object x) {
+        return false;
+    }
+}
+
+// FILE: SpecializedMap.java
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+public class SpecializedMap extends AbstractSpecializedMap {
+    public double put(int x, double y) {
+        return 123.0;
+    }
+
+    @Override
+    public Double get(Object key) {
+        return null;
+    }
+
+    @Override
+    public Double put(Integer key, Double value) {
+        return null;
+    }
+
+    public double remove(int k) {
+        return 456.0;
+    }
+
+
+    public Double remove(Object ok) {
+        return null;
+    }
+
+
+    public double get(int k) {
+        return 789.0;
+    }
+
+    public boolean containsKey(int k) {
+        return true;
+    }
+
+    public boolean containsValue(double v) {
+        return true;
+    }
+
+    @Override
+    public void putAll(Map<? extends Integer, ? extends Double> m) {
+    }
+
+    @Override
+    public void clear() {
+
+    }
+
+    @NotNull
+    @Override
+    public Set<Integer> keySet() {
+        return null;
+    }
+
+    @NotNull
+    @Override
+    public Collection<Double> values() {
+        return null;
+    }
+
+    @NotNull
+    @Override
+    public Set<Entry<Integer, Double>> entrySet() {
+        return null;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+fun box(): String {
+    val x = SpecializedMap()
+    if (!x.containsKey(1)) return "fail 1"
+    if (x.containsKey(null)) return "fail 2"
+
+    if (!x.containsValue(2.0)) return "fail 3"
+    if (x.containsValue(null)) return "fail 4"
+
+    if (x.put(1, 5.0) != 123.0) return "fail 5"
+    if (x.put(1, null) != null) return "fail 6"
+
+    if (x.remove(1) != 456.0) return "fail 7"
+    if (x.remove(null) != null) return "fail 8"
+
+    if (x.get(1) != 789.0) return "fail 9"
+    if (x.get(null) != null) return "fail 10"
+
+    return "OK"
+}

compiler/testData/codegen/box/platformTypes/specializedMapPut.kt

@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// MODULE: lib
+// FILE: A.java
+import java.util.HashMap;
+
+public class A extends HashMap<Integer, Double> {
+    public double put(int x, double y) {
+        return 1.0;
+    }
+
+    @Override
+    public Double put(Integer key, Double value) {
+        return super.put(key, value);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: main.kt
+fun box(): String {
+    val o = A()
+    o.put(1, 2.0)
+
+    return "OK"
+}

compiler/testData/codegen/box/property/fieldAccessFromExtensionInTraitImpl.kt

@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: D.java
+
+public class D {
+    public final String result = "OK";
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+// KT-4878
+
+interface T {
+    fun Int.foo(d: D) = d.result!!
+}
+
+class A : T {
+    fun bar() = 42.foo(D())
+}
+
+fun box() = A().bar()

compiler/testData/codegen/box/property/fieldAccessViaSubclass.kt

@@ -0,0 +1,24 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: D.java
+
+public class D {
+    public String fieldO;
+
+    public static String fieldK;
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+// KT-3492
+
+class MyWrongClass : D() {
+}
+
+fun box() : String {
+    val clazz = MyWrongClass()
+    clazz.fieldO = "O"
+    D.fieldK = "K"
+    return clazz.fieldO!! + D.fieldK!!
+}

compiler/testData/codegen/box/property/referenceToJavaFieldViaBridge.kt

@@ -0,0 +1,24 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: test/D.java
+
+package test;
+
+public class D {
+    protected String field = "OK";
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import test.D
+
+class A : D() {
+    fun a(): String {
+        return {field!!}()
+    }
+}
+
+fun box(): String {
+    return A().a()
+}

compiler/testData/codegen/box/recursiveRawTypes/kt16528.kt

@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaScriptParser.java
+public class JavaScriptParser<T extends JSPsiTypeParser> {
+    public String foo() {return "OK";}
+}
+// FILE: JSPsiTypeParser.java
+public class JSPsiTypeParser<T extends JavaScriptParser> {}
+
+// FILE: ES6Parser.java
+
+public class ES6Parser<T extends JSPsiTypeParser> extends JavaScriptParser<T> {}
+
+// MODULE: main(lib)
+// FILE: main.kt
+
+fun createParser(): JavaScriptParser<*> {
+    return ES6Parser<JSPsiTypeParser<*>>()
+}
+
+fun box(): String = createParser().foo()
+

compiler/testData/codegen/box/recursiveRawTypes/kt16639.kt

@@ -0,0 +1,25 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Device.java
+import java.util.Collection;
+
+public class Device<D extends Device, S extends Service> {
+    public static Collection<Device<Device, Service>> getLoop() {
+        return null;
+    }
+}
+
+// FILE: Service.java
+
+public class Service<D extends Device, S extends Service> {
+}
+
+// MODULE: main(lib)
+// FILE: loop.kt
+
+fun box(): String {
+    val x = Device.getLoop()?.firstOrNull() // compilation error
+    return "OK"
+}

compiler/testData/codegen/box/reflection/classLiterals/javaClassLiteral.kt

@@ -0,0 +1,17 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val j = J::class
+    if (j.simpleName != "J") return "Fail: ${j.simpleName}"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/mapping/jClass2kClass.kt

@@ -0,0 +1,19 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: J.java
+
+public class J {}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    val j = J::class.java
+    assertEquals(j, j.kotlin.java)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/mapping/javaConstructor.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+    public final String result;
+
+    public J(String result) {
+        this.result = result;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val reference = ::J
+    val javaConstructor = reference.javaConstructor ?: return "Fail: no Constructor for reference"
+    val j = javaConstructor.newInstance("OK")
+    val kotlinConstructor = javaConstructor.kotlinFunction
+    if (reference != kotlinConstructor) return "Fail: reference != kotlinConstructor"
+    return j.result
+}

compiler/testData/codegen/box/reflection/mapping/javaFields.kt

@@ -0,0 +1,61 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// FULL_JDK
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+    public final int i;
+    public String s;
+
+    public J(int i, String s) {
+        this.i = i;
+        this.s = s;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.lang.reflect.*
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val i = J::i
+    val s = J::s
+
+    // Check that correct reflection objects are created
+    assert(i !is KMutableProperty<*>) { "Fail i class: ${i.javaClass}" }
+    assert(s is KMutableProperty<*>) { "Fail s class: ${s.javaClass}" }
+
+    // Check that no Method objects are created for such properties
+    assert(i.javaGetter == null) { "Fail i getter" }
+    assert(s.javaGetter == null) { "Fail s getter" }
+    assert(s.javaSetter == null) { "Fail s setter" }
+
+    // Check that correct Field objects are created
+    val ji = i.javaField!!
+    val js = s.javaField!!
+    assert(Modifier.isFinal(ji.getModifiers())) { "Fail i final" }
+    assert(!Modifier.isFinal(js.getModifiers())) { "Fail s final" }
+
+    // Check that those Field objects work as expected
+    val a = J(42, "abc")
+    assert(ji.get(a) == 42) { "Fail ji get" }
+    assert(js.get(a) == "abc") { "Fail js get" }
+    js.set(a, "def")
+    assert(js.get(a) == "def") { "Fail js set" }
+    assert(a.s == "def") { "Fail js access" }
+
+    // Check that valid Kotlin reflection objects are created by those Field objects
+    val ki = ji.kotlinProperty as KProperty1<J, Int>
+    val ks = js.kotlinProperty as KMutableProperty1<J, String>
+    assert(ki.get(a) == 42) { "Fail ki get" }
+    assert(ks.get(a) == "def") { "Fail ks get" }
+    ks.set(a, "ghi")
+    assert(ks.get(a) == "ghi") { "Fail ks set" }
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/mapping/javaMethods.kt

@@ -0,0 +1,36 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: J.java
+
+public class J {
+    public String f(String s) {
+        return s;
+    }
+
+    public static String g(String s) {
+        return s;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+
+fun box(): String {
+    val f = J::f
+    val fm = f.javaMethod ?: return "Fail: no Method for f"
+    if (fm.invoke(J(), "abc") != "abc") return "Fail fm"
+    val ff = fm.kotlinFunction ?: return "Fail: no KFunction for fm"
+    if (f != ff) return "Fail f != ff"
+
+    val g = J::g
+    val gm = g.javaMethod ?: return "Fail: no Method for g"
+    if (gm.invoke(null, "ghi") != "ghi") return "Fail gm"
+    val gg = gm.kotlinFunction ?: return "Fail: no KFunction for gm"
+    if (g != gg) return "Fail g != gg"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/properties/equalsHashCodeToString.kt

@@ -0,0 +1,36 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_REFLECT
+// MODULE: lib
+// FILE: test/J.java
+
+package test;
+
+public class J {
+    public final boolean b;
+    public char c;
+
+    public J() {
+        this.b = false;
+        this.c = '0';
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+package test
+
+import kotlin.test.*
+
+fun box(): String {
+    assertEquals("val test.J.b: kotlin.Boolean", (J::b).toString())
+    assertEquals("var test.J.c: kotlin.Char", (J::c).toString())
+
+    assertTrue(J::b == J::b)
+    assertFalse(J::c == J::b)
+
+    assertTrue(J::b.hashCode() == J::b.hashCode())
+    assertFalse(J::b.hashCode() == J::c.hashCode())
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/bridgesForOverridden.kt

@@ -0,0 +1,40 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public interface Super1<T> {
+        Thread call(T t);
+    }
+
+    public interface Super2<T> {
+        T call(String s);
+    }
+
+    public interface Sub extends Super1<String>, Super2<Thread> {
+        Thread call(String s);
+    }
+
+    static void samAdapter(Sub sub) {
+        ((Super1) sub).call("");
+        ((Super2) sub).call("");
+        sub.call("");
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String? {
+    var s: String?
+    s = "FAIL for function literal"
+    JavaClass.samAdapter { s = "OK"; null }
+    if (s != "OK") return s
+
+    s = "FAIL for wrapper"
+    val function: (String?) -> Thread? = { s = "OK"; null }
+    JavaClass.samAdapter(function)
+    if (s != "OK") return s
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/bridgesForOverriddenComplex.kt

@@ -0,0 +1,31 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+// KT-5912
+class JavaClass<T> {
+    public static interface Action<T> {
+        void call(T t);
+    }
+
+    public static class Some<T> {
+        public Some(T t) {
+        }
+    }
+
+    public static interface OnSubscribe<T> extends Action<Some<T>> {}
+
+    void perform(T t, OnSubscribe<T> subscribe) {
+        subscribe.call(new Some(t));
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+// KT-5912
+fun box(): String {
+    var s = "Failt"
+    JavaClass<String>().perform("") { s = "OK" }
+    return s
+}

compiler/testData/codegen/box/sam/adapters/callAbstractAdapter.kt

@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaInterface.java
+
+interface JavaInterface {
+    void run(Runnable r);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class Impl: JavaInterface {
+    override fun run(r: Runnable?) {
+        r?.run()
+    }
+}
+
+fun box(): String {
+    var v = "FAIL"
+    Impl().run { v = "OK" }
+    return v
+}

compiler/testData/codegen/box/sam/adapters/comparator.kt

@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.*;
+
+class JavaClass {
+    public static void sortIntList(List<Integer> list, Comparator<Integer> comparator) {
+        Collections.sort(list, comparator);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.*
+
+fun box(): String {
+    val list = ArrayList(Arrays.asList(3, 2, 4, 8, 1, 5))
+    val expected = ArrayList(Arrays.asList(8, 5, 4, 3, 2, 1))
+    JavaClass.sortIntList(list, { a, b -> b - a })
+    return if (list == expected) "OK" else list.toString()
+}

compiler/testData/codegen/box/sam/adapters/constructor.kt

@@ -0,0 +1,24 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    JavaClass { v = "OK" }.run()
+    return v
+}

compiler/testData/codegen/box/sam/adapters/doubleLongParameters.kt

@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: GenericInterface.java
+
+interface GenericInterface<T> {
+    public T foo(double d, int i, long j, short s);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal fun getInterface(): GenericInterface<String> {
+    return GenericInterface { d, i, j, s ->
+        "OK"
+    }
+}
+
+fun box(): String {
+    return getInterface().foo(0.0, 0, 0, 0)
+}

compiler/testData/codegen/box/sam/adapters/fileFilter.kt

@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.io.*;
+
+class JavaClass {
+    public static String invokeFilter(FileFilter f, File file1, File file2) {
+        return f.accept(file1) + " " + f.accept(file2);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.io.*
+
+fun box(): String {
+    val ACCEPT_NAME = "test"
+    val WRONG_NAME = "wrong"
+
+    val result = JavaClass.invokeFilter({ file -> ACCEPT_NAME == file?.getName() }, File(ACCEPT_NAME), File(WRONG_NAME))
+
+    if (result != "true false") return "Wrong result: $result"
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/genericSignature.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+class JavaClass {
+    public static String foo(Comparator<String> comparator) {
+        return Arrays.toString(comparator.getClass().getGenericInterfaces());
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val supertypes = JavaClass.foo { a, b -> a.compareTo(b) }
+    if (supertypes != "[java.util.Comparator<java.lang.String>]") return "Fail: $supertypes"
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/implementAdapter.kt

@@ -0,0 +1,25 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: JavaInterface.java
+
+interface JavaInterface {
+    void foo(Runnable r);
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+class Impl: JavaInterface {
+    override fun foo(r: Runnable?) {
+        r?.run()
+    }
+}
+
+fun box(): String {
+    val fooMethods = Impl::class.java.getMethods().filter { it.getName() == "foo" }
+    if (fooMethods.size != 1) return fooMethods.toString()
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/inheritedInKotlin.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public void run(Runnable r) {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+internal class KotlinSubclass: JavaClass() {
+}
+
+fun box(): String {
+    var v = "FAIL"
+    KotlinSubclass().run { v = "OK" }
+    return v
+}

compiler/testData/codegen/box/sam/adapters/inheritedOverriddenAdapter.kt

@@ -0,0 +1,44 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: Super.java
+
+class Super {
+    public String lastCalled = null;
+
+    void foo(Runnable r) {
+        lastCalled = "super";
+    }
+}
+
+// FILE: Sub.java
+
+import kotlin.jvm.functions.Function0;
+import kotlin.Unit;
+
+class Sub extends Super {
+    void foo(Function0<Unit> r) {
+        lastCalled = "sub";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val sub = Sub()
+    val sup: Super = sub
+
+    sup.foo{ }
+    if (sub.lastCalled != "super") {
+        return "FAIL: ${sub.lastCalled} instead of super"
+    }
+
+    sub.foo{ }
+    if (sub.lastCalled != "sub") {
+        return "FAIL: ${sub.lastCalled} instead of sub"
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/inheritedSimple.kt

@@ -0,0 +1,23 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: Sub.java
+
+class Super {
+    void safeInvoke(Runnable r) {
+        if (r != null) r.run();
+    }
+}
+
+class Sub extends Super {
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var r = "FAIL"
+    val sub = Sub()
+    sub.safeInvoke(null)
+    sub.safeInvoke { r = "OK" }
+    return r
+}

compiler/testData/codegen/box/sam/adapters/localClass.kt

@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+var status: String = "fail"  // global property to avoid issues with accessing closure from local class (KT-4174)
+
+fun box(): String {
+    class C() : JavaClass({status = "OK"}) {}
+    C().run()
+    return status
+}

compiler/testData/codegen/box/sam/adapters/localObjectConstructor.kt

@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val x = object : JavaClass({-> v = "OK"}) {}
+    x.run()
+    return v
+}

compiler/testData/codegen/box/sam/adapters/localObjectConstructorWithFnValue.kt

@@ -0,0 +1,26 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = {-> v = "OK"}
+    val x = object : JavaClass(f) {}
+    x.run()
+    return v
+}

compiler/testData/codegen/box/sam/adapters/nonLiteralAndLiteralRunnable.kt

@@ -0,0 +1,20 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static void run(Runnable r1, Runnable r2) {
+        r1.run();
+        r2.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = { v = "O" }
+    JavaClass.run(f, { v += "K" })
+    return v
+}

compiler/testData/codegen/box/sam/adapters/nonLiteralComparator.kt

@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import java.util.*;
+
+class JavaClass {
+    public static void sortIntList(List<Integer> list, Comparator<Integer> comparator) {
+        Collections.sort(list, comparator);
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+import java.util.*
+
+fun box(): String {
+    val list = ArrayList(Arrays.asList(3, 2, 4, 8, 1, 5))
+    val expected = ArrayList(Arrays.asList(8, 5, 4, 3, 2, 1))
+
+    val f = { a: Int, b: Int -> b - a }
+    JavaClass.sortIntList(list, f)
+    return if (list == expected) "OK" else list.toString()
+}

compiler/testData/codegen/box/sam/adapters/nonLiteralInConstructor.kt

@@ -0,0 +1,25 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    private Runnable r;
+
+    public JavaClass(Runnable r) {
+        this.r = r;
+    }
+
+    public void run() {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = { v = "OK" }
+    JavaClass(f).run()
+    return v
+}

compiler/testData/codegen/box/sam/adapters/nonLiteralNull.kt

@@ -0,0 +1,17 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static String run(Runnable r) {
+        return r == null ? "OK" : "FAIL";
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val f: (() -> Unit)? = null
+    return JavaClass.run(f)!!
+}

compiler/testData/codegen/box/sam/adapters/nonLiteralRunnable.kt

@@ -0,0 +1,19 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    public static void run(Runnable r) {
+        r.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var v = "FAIL"
+    val f = { v = "OK" }
+    JavaClass.run(f)
+    return v
+}

compiler/testData/codegen/box/sam/adapters/operators/augmentedAssignmentPure.kt

@@ -0,0 +1,54 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    void plusAssign(Runnable i) {
+        i.run();
+    }
+
+    void minusAssign(Runnable i) {
+        i.run();
+    }
+
+    void timesAssign(Runnable i) {
+        i.run();
+    }
+
+    void divAssign(Runnable i) {
+        i.run();
+    }
+
+    void remAssign(Runnable i) {
+        i.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj += { v1 = "OK" }
+    if (v1 != "OK") return "plus: $v1"
+
+    var v2 = "FAIL"
+    obj -= { v2 = "OK" }
+    if (v2 != "OK") return "minus: $v2"
+
+    var v3 = "FAIL"
+    obj *= { v3 = "OK" }
+    if (v3 != "OK") return "times: $v3"
+
+    var v4 = "FAIL"
+    obj /= { v4 = "OK" }
+    if (v4 != "OK") return "div: $v4"
+
+    var v5 = "FAIL"
+    obj %= { v5 = "OK" }
+    if (v5 != "OK") return "mod: $v5"
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/operators/augmentedAssignmentViaSimpleBinary.kt

@@ -0,0 +1,61 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+import org.jetbrains.annotations.NotNull;
+
+class JavaClass {
+    @NotNull JavaClass plus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass minus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass times(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass div(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    @NotNull JavaClass rem(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    var obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj += { v1 = "OK" }
+    if (v1 != "OK") return "plus: $v1"
+
+    var v2 = "FAIL"
+    obj -= { v2 = "OK" }
+    if (v2 != "OK") return "minus: $v2"
+
+    var v3 = "FAIL"
+    obj *= { v3 = "OK" }
+    if (v3 != "OK") return "times: $v3"
+
+    var v4 = "FAIL"
+    obj /= { v4 = "OK" }
+    if (v4 != "OK") return "div: $v4"
+
+    var v5 = "FAIL"
+    obj %= { v5 = "OK" }
+    if (v5 != "OK") return "mod: $v5"
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/operators/binary.kt

@@ -0,0 +1,68 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    JavaClass plus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass minus(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass times(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass div(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass rem(Runnable i) {
+        i.run();
+        return this;
+    }
+
+    JavaClass rangeTo(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj + { v1 = "OK" }
+    if (v1 != "OK") return "plus: $v1"
+
+    var v2 = "FAIL"
+    obj - { v2 = "OK" }
+    if (v2 != "OK") return "minus: $v2"
+
+    var v3 = "FAIL"
+    obj * { v3 = "OK" }
+    if (v3 != "OK") return "times: $v3"
+
+    var v4 = "FAIL"
+    obj / { v4 = "OK" }
+    if (v4 != "OK") return "div: $v4"
+
+    var v5 = "FAIL"
+    obj % { v5 = "OK" }
+    if (v5 != "OK") return "mod: $v5"
+
+    var v6 = "FAIL"
+    obj .. { v6 = "OK" }
+    if (v6 != "OK") return "rangeTo: $v6"
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/operators/compareTo.kt

@@ -0,0 +1,35 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    int compareTo(Runnable i) {
+        i.run();
+        return 239;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v1 = "FAIL"
+    obj < { v1 = "OK" }
+    if (v1 != "OK") return "<: $v1"
+
+    var v2 = "FAIL"
+    obj > { v2 = "OK" }
+    if (v2 != "OK") return ">: $v2"
+
+    var v3 = "FAIL"
+    obj <= { v3 = "OK" }
+    if (v3 != "OK") return "<=: $v3"
+
+    var v4 = "FAIL"
+    obj >= { v4 = "OK" }
+    if (v4 != "OK") return ">=: $v4"
+
+    return "OK"
+}

compiler/testData/codegen/box/sam/adapters/operators/contains.kt

@@ -0,0 +1,22 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    boolean contains(Runnable i) {
+        i.run();
+        return true;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    { v = "O" } in obj
+    { v += "K" } !in obj
+    return v
+}

compiler/testData/codegen/box/sam/adapters/operators/get.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    int get(Runnable i) {
+        i.run();
+        return 239;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    obj[{ v = "OK" }]
+    return v
+}

compiler/testData/codegen/box/sam/adapters/operators/invoke.kt

@@ -0,0 +1,21 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// MODULE: lib
+// FILE: JavaClass.java
+
+class JavaClass {
+    void invoke(Runnable i) {
+        i.run();
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val obj = JavaClass()
+
+    var v = "FAIL"
+    obj({ v = "O" })
+    obj { v += "K" }
+    return v
+}

compiler/testData/codegen/box/sam/adapters/operators/legacyModOperator.kt

@@ -0,0 +1,49 @@
+// DONT_TARGET_EXACT_BACKEND: JS JS_IR JS_IR_ES6 WASM NATIVE
+// !LANGUAGE: -ProhibitOperatorMod
+// IGNORE_BACKEND_FIR: JVM_IR
+// MODULE: lib
+// FILE: Java.java
+
+import org.jetbrains.annotations.NotNull;
+
+class AugmentedAssignmentPure {
+    void modAssign(Runnable i) {
+        i.run();
+    }
+}
+
+class AugmentedAssignmentViaSimpleBinary {
+    @NotNull AugmentedAssignmentViaSimpleBinary rem(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+class Binary {
+    Binary rem(Runnable i) {
+        i.run();
+        return this;
+    }
+}
+
+// MODULE: main(lib)
+// FILE: 1.kt
+
+fun box(): String {
+    val augAssignmentPure = AugmentedAssignmentPure()
+    var v1 = "FAIL"
+    augAssignmentPure %= { v1 = "OK" }
+    if (v1 != "OK") return "assignment pure: $v1"
+
+    var augmentedAssignmentViaSimpleBinary = AugmentedAssignmentViaSimpleBinary()
+    var v2 = "FAIL"
+    augmentedAssignmentViaSimpleBinary %= { v2 = "OK" }
+    if (v2 != "OK") return "assignment via simple binary: $v2"
+
+    val binary = Binary()
+    var v3 = "FAIL"
+    binary % { v3 = "OK" }
+    if (v3 != "OK") return "binary: $v3"
+
+    return "OK"
+}