Codegen tests for inner/nested classes

#KT-1174 In Progress

compiler/testData/codegen/innerNested/createNestedClass.kt

@@ -0,0 +1,13 @@
+class A {
+    class B1
+    class B2(val x: Int)
+    class B3(val x: Long, val y: Int)
+    class B4(val str: String)
+}
+
+
+fun box(): String {
+    A.B1()
+    val b2 = A.B2(A.B3(42, 42).y)
+    return A.B4("OK").str
+}

compiler/testData/codegen/innerNested/dataLocalVariable.kt

@@ -0,0 +1,6 @@
+fun ok(b: Boolean) = if (b) "OK" else "Fail"
+
+fun box(): String {
+    val data = java.util.Arrays.asList("foo", "bar")!!
+    return ok(data.contains("foo"))
+}

compiler/testData/codegen/innerNested/extensionFun.kt

@@ -0,0 +1,31 @@
+class Outer {
+    class Nested
+    inner class Inner
+    
+    fun Inner.foo() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun Nested.bar() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun Outer.baz() {
+        Outer()
+        Nested()
+        Inner()
+    }
+    
+    fun box(): String {
+        Inner().foo()
+        Nested().bar()
+        baz()
+        return "OK"
+    }
+}
+
+fun box() = Outer().box()

compiler/testData/codegen/innerNested/importNestedClass.kt

@@ -0,0 +1,18 @@
+import A.B
+import A.B.C
+
+class A {
+    class B {
+        class C
+    }
+}
+
+fun box(): String {
+    val a = A()
+    val b = B()
+    val ab = A.B()
+    val c = C()
+    val bc = B.C()
+    val abc = A.B.C()
+    return "OK"
+}

compiler/testData/codegen/innerNested/innerGeneric.kt

@@ -0,0 +1,11 @@
+class Outer {
+    inner class Inner<T>(val t: T) {
+        fun box() = t
+    }
+}
+
+fun box(): String {
+    if (Outer().Inner("OK").box() != "OK") return "Fail"
+    val x: Outer.Inner<String> = Outer().Inner("OK")
+    return x.box()
+}

compiler/testData/codegen/innerNested/innerLabeledThis.kt

@@ -0,0 +1,11 @@
+class Outer {
+    inner class Inner {
+        fun O() = this@Outer.O
+        val K = this@Outer.K()
+    }
+    
+    val O = "O"
+    fun K() = "K"
+}
+
+fun box() = Outer().Inner().O() + Outer().Inner().K

compiler/testData/codegen/innerNested/innerSimple.kt

@@ -0,0 +1,7 @@
+class Outer {
+    inner class Inner {
+        fun box() = "OK"
+    }
+}
+
+fun box() = Outer().Inner().box()

compiler/testData/codegen/innerNested/nestedClassObject.kt

@@ -0,0 +1,12 @@
+class Outer {
+    class Nested {
+        class object {
+            val O = "O"
+            val K = "K"
+        }
+    }
+    
+    fun O() = Nested.O
+}
+
+fun box() = Outer().O() + Outer.Nested.K

compiler/testData/codegen/innerNested/nestedEnumConstant.kt

@@ -0,0 +1,8 @@
+class Outer {
+    enum class Nested {
+        O
+        K
+    }
+}
+
+fun box() = "${Outer.Nested.O}${Outer.Nested.K}"

compiler/testData/codegen/innerNested/nestedGeneric.kt

@@ -0,0 +1,12 @@
+class Outer {
+    class Nested<T>(val t: T) {
+        fun box() = t
+    }
+}
+
+fun box(): String {
+    if (Outer.Nested<String>("OK").box() != "OK") return "Fail"
+    
+    val x: Outer.Nested<String> = Outer.Nested("OK")
+    return x.box()
+}

compiler/testData/codegen/innerNested/nestedInPackage.kt

@@ -0,0 +1,10 @@
+package Package
+
+class Outer {
+    class Nested {
+        val O = "O"
+        val K = "K"
+    }
+}
+
+fun box() = Package.Outer.Nested().O + Outer.Nested().K

compiler/testData/codegen/innerNested/nestedObjects.kt

@@ -0,0 +1,9 @@
+object A {
+    object B {
+        object C {
+            val ok = "OK"
+        }
+    }
+}
+
+fun box() = A.B.C.ok

compiler/testData/codegen/innerNested/nestedSimple.kt

@@ -0,0 +1,7 @@
+class Outer {
+    class Nested {
+        fun box() = "OK"
+    }
+}
+
+fun box() = Outer.Nested().box()