Supported nested reified parameter declarations

Also switched to using type names as identifiers instead of their
indices

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

@@ -0,0 +1,36 @@
+import kotlin.test.assertEquals
+
+trait A {
+    fun f1(): String
+    fun f2(): String
+    fun f3(): String
+}
+
+fun doWork(block: () -> String) = block()
+inline fun doWorkInline(block: () -> String) = block()
+
+fun box(): String {
+    val x = object {
+        inline fun <reified T> bar1(): A = object : A {
+            override fun f1(): String = javaClass<T>().getName()
+            override fun f2(): String = doWork { javaClass<T>().getName() }
+            override fun f3(): String = doWorkInline { javaClass<T>().getName() }
+        }
+
+        inline fun <reified T> bar2() = javaClass<T>().getName()
+        inline fun <reified T> bar3() = doWork { javaClass<T>().getName() }
+        inline fun <reified T> bar4() = doWorkInline { javaClass<T>().getName() }
+    }
+
+    val y: A = x.bar1<String>()
+    assertEquals("java.lang.String", y.f1())
+    assertEquals("java.lang.String", y.f2())
+    assertEquals("java.lang.String", y.f3())
+
+
+    assertEquals("java.lang.Integer", x.bar2<Int>())
+    assertEquals("java.lang.Double", x.bar3<Double>())
+    assertEquals("java.lang.Long", x.bar4<Long>())
+
+    return "OK"
+}

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

@@ -0,0 +1,42 @@
+import kotlin.test.assertEquals
+
+inline fun <reified T, reified R> foo(): Array<String> {
+    val x = object {
+        inline fun <reified T1, reified T> bar(): Array<String> = array(
+                javaClass<T1>().getName(), javaClass<T>().getName(), javaClass<R>().getName()
+        )
+        fun f1() = bar<T, R>()
+        fun f2() = bar<R, T>()
+        fun f3() = bar<Boolean, T>()
+        fun f4() = bar<T, Boolean>()
+    }
+
+    val x1 = x.f1()
+    val x2 = x.f2()
+    val x3 = x.f3()
+    val x4 = x.f4()
+
+    return array(
+            x1[0], x1[1], x1[2],
+            x2[0], x2[1], x2[2],
+            x3[0], x3[1], x3[2],
+            x4[0], x4[1], x4[2]
+    )
+}
+
+fun box(): String {
+    val result = foo<Double, Int>()
+
+    val expected = array(
+            "java.lang.Double", "java.lang.Integer", "java.lang.Integer",
+            "java.lang.Integer", "java.lang.Double", "java.lang.Integer",
+            "java.lang.Boolean", "java.lang.Double", "java.lang.Integer",
+            "java.lang.Double", "java.lang.Boolean", "java.lang.Integer"
+    )
+
+    for (i in expected.indices) {
+        assertEquals(expected[i], result[i], "$i-th element")
+    }
+
+    return "OK"
+}

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

@@ -0,0 +1,32 @@
+import kotlin.test.assertEquals
+
+open class A<T1, T2, T3>
+
+inline fun <reified T, reified R> foo(): Array<A<*,*,*>> {
+    val x = object {
+        inline fun <reified T1, reified T> bar(): A<*,*,*> = object : A<T1,T,R>() {}
+        fun f1() = bar<T, R>()
+        fun f2() = bar<R, T>()
+        fun f3() = bar<Boolean, T>()
+        fun f4() = bar<T, Boolean>()
+    }
+
+    return array(x.f1(), x.f2(), x.f3(), x.f4())
+}
+
+fun box(): String {
+    val result = foo<Double, Int>()
+
+    val expected = array(
+            Triple("java.lang.Double", "java.lang.Integer", "java.lang.Integer"),
+            Triple("java.lang.Integer", "java.lang.Double", "java.lang.Integer"),
+            Triple("java.lang.Boolean", "java.lang.Double", "java.lang.Integer"),
+            Triple("java.lang.Double", "java.lang.Boolean", "java.lang.Integer")
+    ).map { "A<${it.first}, ${it.second}, ${it.third}>" }
+
+    for (i in expected.indices) {
+        assertEquals(expected[i], result[i].javaClass.getGenericSuperclass()?.toString(), "$i-th element")
+    }
+
+    return "OK"
+}

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

@@ -0,0 +1,21 @@
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+trait A {
+    fun f(): String
+    fun g(): String
+}
+
+fun box(): String {
+    val x: A = object : A {
+        private inline fun <reified T> localClassName(): String = javaClass<T>().getName()
+        override fun f(): String = foo { localClassName<String>() }
+        override fun g(): String = foo { localClassName<Int>() }
+    }
+
+    assertEquals("java.lang.String", x.f())
+    assertEquals("java.lang.Integer", x.g())
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+import kotlin.test.assertEquals
+
+fun foo(block: () -> String) = block()
+
+inline fun <reified T> className(): String = javaClass<T>().getName()
+
+inline fun <reified T> lambdaShouldBeReified(): String = foo { className<T>() }
+
+trait A {
+    fun f(): String
+    fun g(): String
+}
+inline fun<reified T1, reified T2> AFactory(): A = object : A {
+    override fun f(): String = className<T1>()
+    override fun g(): String = foo { className<T2>() }
+}
+
+fun box(): String {
+    assertEquals("java.lang.String", lambdaShouldBeReified<String>())
+    assertEquals("java.lang.Integer", lambdaShouldBeReified<Int>())
+
+    val x: A = AFactory<String, Int>()
+
+    assertEquals("java.lang.String", x.f())
+    assertEquals("java.lang.Integer", x.g())
+
+    return "OK"
+}