Write outer class info for closures

compiler/testData/codegen/boxWithStdlib/reflection/lambda/lambdaInConstructor.kt

@@ -0,0 +1,17 @@
+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/boxWithStdlib/reflection/lambda/lambdaInFunction.kt

@@ -0,0 +1,15 @@
+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()
+    if (!enclosingClass!!.getName().startsWith("_DefaultPackage-lambdaInFunction-")) return "enclosing class: $enclosingClass"
+
+    val declaringClass = javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reflection/lambda/lambdaInLambda.kt

@@ -0,0 +1,17 @@
+fun box(): String {
+    val l = {
+        {}
+    }
+
+    val javaClass = l().javaClass
+    val enclosingMethod = javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "invoke") return "method: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (enclosingClass!!.getName() != "_DefaultPackage\$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/boxWithStdlib/reflection/lambda/lambdaInLocalClass.kt

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

compiler/testData/codegen/boxWithStdlib/reflection/lambda/lambdaInLocalFunction.kt

@@ -0,0 +1,17 @@
+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()
+    if (enclosingClass!!.getName() != "_DefaultPackage\$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/boxWithStdlib/reflection/lambda/lambdaInMemberFunction.kt

@@ -0,0 +1,20 @@
+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/boxWithStdlib/reflection/lambda/lambdaInMemberFunctionInLocalClass.kt

@@ -0,0 +1,19 @@
+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()
+    if (enclosingClass?.getName() != "_DefaultPackage\$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/boxWithStdlib/reflection/lambda/lambdaInMemberFunctionInNestedClass.kt

@@ -0,0 +1,21 @@
+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/boxWithStdlib/reflection/lambda/lambdaInObjectExpression.kt

@@ -0,0 +1,18 @@
+open class C(val a: Any)
+
+fun box(): String {
+    val l = object : C({}) {
+    }
+
+    val javaClass = l.a.javaClass
+    val enclosingMethod = javaClass.getEnclosingConstructor()
+    if (enclosingMethod?.getName() != "_DefaultPackage\$box\$l\$1") return "ctor: $enclosingMethod"
+
+    val enclosingClass = javaClass.getEnclosingClass()
+    if (!enclosingClass!!.getName().startsWith("_DefaultPackage\$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/boxWithStdlib/reflection/lambda/lambdaInPackage.kt

@@ -0,0 +1,17 @@
+val l: Any = {}
+
+fun box(): String {
+    val enclosingClass = l.javaClass.getEnclosingClass()
+    if (!enclosingClass!!.getName().startsWith("_DefaultPackage-lambdaInPackage-")) 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/boxWithStdlib/reflection/lambda/lambdaInPropertyGetter.kt

@@ -0,0 +1,16 @@
+val l: Any
+    get() = {}
+
+fun box(): String {
+
+    val enclosingMethod = l.javaClass.getEnclosingMethod()
+    if (enclosingMethod?.getName() != "getL") return "method: $enclosingMethod"
+
+    val enclosingClass = l.javaClass.getEnclosingClass()
+    if (!enclosingClass!!.getName().startsWith("_DefaultPackage-lambdaInPropertyGetter-")) 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/boxWithStdlib/reflection/lambda/lambdaInPropertySetter.kt

@@ -0,0 +1,23 @@
+
+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()
+    if (!enclosingClass!!.getName().startsWith("_DefaultPackage-lambdaInPropertySetter-")) return "enclosing class: $enclosingClass"
+
+    val declaringClass = l.javaClass.getDeclaringClass()
+    if (declaringClass != null) return "anonymous function has a declaring class: $declaringClass"
+
+    return "OK"
+}