Merge boxWithStdlib testData into box, delete BoxWithStdlib test

compiler/testData/codegen/box/reflection/enclosing/anonymousObjectInInlinedLambda.kt

@@ -0,0 +1,22 @@
+// WITH_REFLECT
+
+interface A {
+    fun f(): String
+}
+
+inline fun foo(): A {
+    return object : A {
+        override fun f(): String {
+            return "OK"
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo()
+
+    val enclosing = y.javaClass.getEnclosingMethod()
+    if (enclosing?.getName() != "foo") return "method: $enclosing"
+
+    return y.f()
+}

compiler/testData/codegen/box/reflection/enclosing/classInLambda.kt

@@ -0,0 +1,20 @@
+// WITH_REFLECT
+
+fun box(): String {
+
+    val classInLambda = {
+        class Z {}
+        Z()
+    }()
+
+    val enclosingMethod = classInLambda.javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "invoke") return "method: $enclosingMethod"
+
+    val enclosingClass = classInLambda.javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "ClassInLambdaKt\$box\$classInLambda\$1") return "enclosing class: $enclosingClass"
+
+    val declaringClass = classInLambda.javaClass.getDeclaringClass()
+    if (declaringClass != null) return "class has a declaring class"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/functionExpressionInProperty.kt

@@ -0,0 +1,18 @@
+// WITH_REFLECT
+
+val property = fun () {}
+
+fun box(): String {
+    val javaClass = property.javaClass
+
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod != null) return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "FunctionExpressionInPropertyKt") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/kt6368.kt

@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+import java.util.HashMap
+
+interface R {
+    fun result(): String
+}
+
+val a by lazy {
+    with(HashMap<String, R>()) {
+        put("result", object : R {
+            override fun result(): String = "OK"
+        })
+        this
+    }
+}
+
+fun box(): String {
+    val r = a["result"]!!
+
+    // Check that reflection won't fail
+    r.javaClass.getEnclosingMethod().toString()
+
+    return r.result()
+}

compiler/testData/codegen/box/reflection/enclosing/kt6691_lambdaInSamConstructor.kt

@@ -0,0 +1,26 @@
+// WITH_REFLECT
+
+var lambda = {}
+
+class A {
+    val prop = Runnable {
+        lambda = { println("") }
+    }
+}
+
+fun box(): String {
+    A().prop.run()
+
+    val javaClass = lambda.javaClass
+
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "run") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "A\$prop\$1") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInClassObject.kt

@@ -0,0 +1,27 @@
+// WITH_REFLECT
+
+class O {
+    companion object {
+        // Currently we consider <clinit> in class O as the enclosing method of this lambda,
+        // so we write outer class = O and enclosing method = null
+        val f = {}
+    }
+}
+
+fun box(): String {
+    val javaClass = O.f.javaClass
+
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod != null) return "method: $enclosingMethod"
+
+    val enclosingConstructor = javaClass.getEnclosingConstructor()
+    if (enclosingConstructor != null) return "constructor: $enclosingConstructor"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (enclosingClass?.getName() != "O") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInConstructor.kt

@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+class C {
+    val l: Any = {}
+}
+
+fun box(): String {
+    val javaClass = C().l.javaClass
+    val enclosingConstructor = javaClass.getEnclosingConstructor()
+    if (enclosingConstructor?.getDeclaringClass()?.getName() != "C") return "ctor: $enclosingConstructor"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (enclosingClass?.getName() != "C") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInFunction.kt

@@ -0,0 +1,17 @@
+// WITH_REFLECT
+
+fun box(): String {
+    val l: Any = {}
+
+    val javaClass = l.javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "box") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInFunctionKt") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInLambda.kt

@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+fun box(): String {
+    val l = {
+        {}
+    }
+
+    val javaClass = l().javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "invoke") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInLambdaKt\$box\$l\$1") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalClassConstructor.kt

@@ -0,0 +1,28 @@
+// WITH_REFLECT
+
+open class C
+
+fun box(): String {
+    class L : C() {
+        val a: Any
+
+        init {
+            a = {}
+        }
+    }
+    val l = L()
+
+    val javaClass = l.a.javaClass
+    val enclosingMethod = javaClass.getEnclosingConstructor()!!.getName()
+    if (enclosingMethod != "LambdaInLocalClassConstructorKt\$box\$L") return "ctor: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInLocalClassConstructorKt\$box\$L") return "enclosing class: $enclosingClass"
+
+    if (enclosingMethod != enclosingClass) return "$enclosingClass != $enclosingMethod"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalClassSuperCall.kt

@@ -0,0 +1,23 @@
+// WITH_REFLECT
+
+open class C(val a: Any)
+
+fun box(): String {
+    class L : C({}) {
+    }
+    val l = L()
+
+    val javaClass = l.a.javaClass
+    val enclosingMethod = javaClass.getEnclosingConstructor()!!.getName()
+    if (enclosingMethod != "LambdaInLocalClassSuperCallKt\$box\$L") return "ctor: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInLocalClassSuperCallKt\$box\$L") return "enclosing class: $enclosingClass"
+
+    if (enclosingMethod != enclosingClass) return "$enclosingClass != $enclosingMethod"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalFunction.kt

@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+fun box(): String {
+    fun foo(): Any {
+        return {}
+    }
+
+    val javaClass = foo().javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "invoke") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInLocalFunctionKt\$box$1") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInMemberFunction.kt

@@ -0,0 +1,22 @@
+// WITH_REFLECT
+
+class C {
+    fun foo(): Any {
+        return {}
+    }
+}
+
+
+fun box(): String {
+    val javaClass = C().foo().javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "foo") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (enclosingClass?.getName() != "C") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInMemberFunctionInLocalClass.kt

@@ -0,0 +1,21 @@
+// WITH_REFLECT
+
+fun box(): String {
+    class C {
+        fun foo(): Any {
+            return {}
+        }
+    }
+
+    val javaClass = C().foo().javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "foo") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInMemberFunctionInLocalClassKt\$box\$C") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInMemberFunctionInNestedClass.kt

@@ -0,0 +1,23 @@
+// WITH_REFLECT
+
+class C {
+    class D {
+        fun foo(): Any {
+            return {}
+        }
+    }
+}
+
+fun box(): String {
+    val javaClass = C.D().foo().javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "foo") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (enclosingClass?.getSimpleName() != "D") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectDeclaration.kt

@@ -0,0 +1,23 @@
+// WITH_REFLECT
+
+object O {
+    val f = {}
+}
+
+fun box(): String {
+    val javaClass = O.f.javaClass
+
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod != null) return "method: $enclosingMethod"
+
+    val enclosingConstructor = javaClass.getEnclosingConstructor()
+    if (enclosingConstructor == null) return "no enclosing constructor"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (enclosingClass?.getName() != "O") return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectExpression.kt

@@ -0,0 +1,29 @@
+// WITH_REFLECT
+
+interface C {
+    val a: Any
+}
+
+fun box(): String {
+    val l = object : C {
+        override val a: Any
+
+        init {
+            a = {}
+        }
+    }
+
+    val javaClass = l.a.javaClass
+    val enclosingMethod = javaClass.getEnclosingConstructor()!!.getName()
+    if (enclosingMethod != "LambdaInObjectExpressionKt\$box\$l\$1") return "ctor: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInObjectExpressionKt\$box\$l\$1") return "enclosing class: $enclosingClass"
+
+    if (enclosingMethod != enclosingClass) return "$enclosingClass != $enclosingMethod"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInObjectLiteralSuperCall.kt

@@ -0,0 +1,23 @@
+// WITH_REFLECT
+
+open class C(val a: Any)
+
+fun box(): String {
+    val l = object : C({}) {
+    }
+
+    val javaClass = l.a.javaClass
+    if (javaClass.getEnclosingConstructor() != null) return "ctor should be null"
+
+    val enclosingMethod = javaClass.getEnclosingMethod()!!.getName()
+    if (enclosingMethod != "box") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInObjectLiteralSuperCallKt" || enclosingClass != l.javaClass.getEnclosingClass()!!.getName())
+        return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInPackage.kt

@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+val l: Any = {}
+
+fun box(): String {
+    val enclosingClass = l.javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInPackageKt") return "enclosing class: $enclosingClass"
+
+    val enclosingConstructor = l.javaClass.getEnclosingConstructor()
+    if (enclosingConstructor != null) return "enclosing constructor found: $enclosingConstructor"
+
+    val enclosingMethod = l.javaClass.getEnclosingMethod()
+    if (enclosingMethod != null) return "enclosing method found: $enclosingMethod"
+
+    val declaringClass = l.javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInPropertyGetter.kt

@@ -0,0 +1,18 @@
+// WITH_REFLECT
+
+val l: Any
+    get() = {}
+
+fun box(): String {
+
+    val enclosingMethod = l.javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "getL") return "method: $enclosingMethod"
+
+    val enclosingClass = l.javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInPropertyGetterKt") return "enclosing class: $enclosingClass"
+
+    val declaringClass = l.javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/lambdaInPropertySetter.kt

@@ -0,0 +1,24 @@
+// WITH_REFLECT
+
+var _l: Any = ""
+
+var l: Any
+    get() = _l
+    set(v) {
+        _l = {}
+    }
+
+fun box(): String {
+    l = "" // to invoke the setter
+
+    val enclosingMethod = l.javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "setL") return "method: $enclosingMethod"
+
+    val enclosingClass = l.javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "LambdaInPropertySetterKt") return "enclosing class: $enclosingClass"
+
+    val declaringClass = l.javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/localClassInTopLevelFunction.kt

@@ -0,0 +1,11 @@
+// WITH_REFLECT
+// KT-4234
+
+fun box(): String {
+    class C
+
+    val name = C::class.java.getSimpleName()
+    if (name != "box\$C") return "Fail: $name"
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/enclosing/objectInLambda.kt

@@ -0,0 +1,19 @@
+// WITH_REFLECT
+
+fun box(): String {
+
+    val objectInLambda = {
+        object : Any () {}
+    }()
+
+    val enclosingMethod = objectInLambda.javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "invoke") return "method: $enclosingMethod"
+
+    val enclosingClass = objectInLambda.javaClass.getEnclosingClass()!!.getName()
+    if (enclosingClass != "ObjectInLambdaKt\$box\$objectInLambda\$1") return "enclosing class: $enclosingClass"
+
+    val declaringClass = objectInLambda.javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous object has a declaring class"
+
+    return "OK"
+}