Supported reification for anonymous objects and lambdas

compiler/testData/codegen/boxWithStdlib/reified/anonymousObject.kt

@@ -0,0 +1,19 @@
+import kotlin.test.assertEquals
+
+abstract class A {
+    abstract fun f(): String
+}
+
+inline fun<reified T> foo(): A {
+    return object : A() {
+        override fun f(): String {
+            return javaClass<T>().getName()
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo<String>();
+    assertEquals("java.lang.String", y.f())
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reified/anonymousObjectReifiedSupertype.kt

@@ -0,0 +1,20 @@
+import kotlin.test.assertEquals
+
+abstract class A<R> {
+    abstract fun f(): String
+}
+
+inline fun<reified T> foo(): A<T> {
+    return object : A<T>() {
+        override fun f(): String {
+            return "OK"
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo<String>();
+    assertEquals("OK", y.f())
+    assertEquals("A<java.lang.String>", y.javaClass.getGenericSuperclass()?.toString())
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reified/innerAnonymousObject.kt

@@ -0,0 +1,27 @@
+import kotlin.test.assertEquals
+
+abstract class A<R> {
+    abstract fun f(): String
+    override fun toString() = f()
+}
+
+abstract class G {
+    abstract fun bar(): Any
+}
+
+inline fun<reified T> foo(): G {
+    return object : G() {
+        override fun bar(): Any {
+            return object : A<T>() {
+                 override fun f(): String = "OK"
+            }
+        }
+    }
+}
+
+fun box(): String {
+    val y = foo<String>().bar();
+    assertEquals("OK", y.toString())
+    assertEquals("A<java.lang.String>", y.javaClass.getGenericSuperclass()?.toString())
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reified/nonInlineableLambdaInReifiedFunction.kt

@@ -0,0 +1,17 @@
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+inline fun<reified T> bar1(x: T): String = foo() {
+    javaClass<T>().getName()
+}
+inline fun<reified T> bar2(x: T, y: String): String = foo() {
+    javaClass<T>().getName() + "#" + y
+}
+
+fun box(): String {
+
+    assertEquals("java.lang.Integer", bar1(1))
+    assertEquals("java.lang.String#OK", bar2("abc", "OK"))
+
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reified/recursiveInnerAnonymousObject.kt

@@ -0,0 +1,35 @@
+import kotlin.test.assertEquals
+
+abstract class A<R> {
+    abstract fun f(): String
+    override fun toString() = f()
+}
+
+abstract class G {
+    abstract fun bar(): Any
+}
+
+inline fun<reified T> baz(): G {
+    return object : G() {
+        override fun bar(): Any {
+            return object : A<T>() {
+                override fun f(): String = "OK"
+            }
+        }
+    }
+}
+
+inline fun<T1, T2, T3, T4, T5, T6, reified R1, reified R2> foo(): Pair<G, G> {
+    return Pair(baz<R1>(), baz<R2>())
+}
+
+fun box(): String {
+    val res = foo<Int, Int, Int, Int, Int, Int, Int, String>();
+    val x1 = res.first.bar()
+    val x2 = res.second.bar()
+    assertEquals("OK", x1.toString())
+    assertEquals("OK", x2.toString())
+    assertEquals("A<java.lang.Integer>", x1.javaClass.getGenericSuperclass()?.toString())
+    assertEquals("A<java.lang.String>", x2.javaClass.getGenericSuperclass()?.toString())
+    return "OK"
+}

compiler/testData/codegen/boxWithStdlib/reified/recursiveNonInlineableLambda.kt

@@ -0,0 +1,22 @@
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+inline fun<reified T> bar1(): String = foo() {
+    javaClass<T>().getName()
+}
+inline fun<reified T> bar2(y: String): String = foo() {
+    javaClass<T>().getName() + "#" + y
+}
+
+inline fun<T1, T2, reified R1, reified R2> bar3(y: String) =
+        Pair(bar1<R1>(), bar2<R2>(y))
+
+fun box(): String {
+    val x = bar3<Any, Double, Int, String>("OK")
+
+    assertEquals("java.lang.Integer", x.first)
+    assertEquals("java.lang.String#OK", x.second)
+
+    return "OK"
+}