Local objects (#215)

* bug fix

* bug fix with nested inner classes

* - fixed FixMeInner
- support of inner classes in local classes
- support of object expressions in initializers

* comments

* merged modification

* - review fixes
- tests

* review fixes

* review fixes

backend.native/tests/build.gradle

@@ -357,11 +357,46 @@ task innerClass_generic(type: RunKonanTest) {
     source = "codegen/innerClass/generic.kt"
 }
 
+task innerClass_doubleInner(type: RunKonanTest) {
+    goldValue = "OK\n"
+    source = "codegen/innerClass/doubleInner.kt"
+}
+
 task innerClass_qualifiedThis(type: RunKonanTest) {
     goldValue = "OK\n"
     source = "codegen/innerClass/qualifiedThis.kt"
 }
 
+task innerClass_superOuter(type: RunKonanTest) {
+    goldValue = "OK\n"
+    source = "codegen/innerClass/superOuter.kt"
+}
+
+task localClass_localHierarchy(type: RunKonanTest) {
+    goldValue = "OK\n"
+    source = "codegen/localClass/localHierarchy.kt"
+}
+
+task localClass_objectExpressionInProperty(type: RunKonanTest) {
+    goldValue = "OK\n"
+    source = "codegen/localClass/objectExpressionInProperty.kt"
+}
+
+task localClass_objectExpressionInInitializer(type: RunKonanTest) {
+    goldValue = "OK\n"
+    source = "codegen/localClass/objectExpressionInInitializer.kt"
+}
+
+task localClass_innerWithCapture(type: RunKonanTest) {
+    goldValue = "OK\n"
+    source = "codegen/localClass/innerWithCapture.kt"
+}
+
+task localClass_innerTakesCapturedFromOuter(type: RunKonanTest) {
+    goldValue = "0\n1\n"
+    source = "codegen/localClass/innerTakesCapturedFromOuter.kt"
+}
+
 task array0(type: RunKonanTest) {
     goldValue = "5\n6\n7\n8\n9\n10\n11\n12\n13\n"
     source = "runtime/collections/array0.kt"

backend.native/tests/codegen/innerClass/doubleInner.kt

@@ -0,0 +1,21 @@
+open class Father(val param: String) {
+    abstract inner class InClass {
+        fun work(): String {
+            return param
+        }
+    }
+
+    inner class Child(p: String) : Father(p) {
+        inner class Child2 : Father.InClass {
+            constructor(): super()
+        }
+    }
+}
+
+fun box(): String {
+    return Father("fail").Child("OK").Child2().work()
+}
+
+fun main(args: Array<String>) {
+    println(box())
+}

backend.native/tests/codegen/innerClass/superOuter.kt

@@ -0,0 +1,13 @@
+open class Outer(val outer: String) {
+    open inner class Inner(val inner: String): Outer(inner) {
+        fun foo() = outer
+    }
+
+    fun value() = Inner("OK").foo()
+}
+
+fun box() = Outer("Fail").value()
+
+fun main(args : Array<String>) {
+    println(box())
+}

backend.native/tests/codegen/localClass/innerTakesCapturedFromOuter.kt

@@ -0,0 +1,18 @@
+fun box() {
+    var previous: Any? = null
+    for (i in 0 .. 2) {
+        class Outer {
+            inner class Inner {
+                override fun toString() = i.toString()
+            }
+
+            override fun toString() = Inner().toString()
+        }
+        if (previous != null) println(previous.toString())
+        previous = Outer()
+    }
+}
+
+fun main(args: Array<String>) {
+    box()
+}

backend.native/tests/codegen/localClass/innerWithCapture.kt

@@ -0,0 +1,13 @@
+fun box(s: String): String {
+    class Local {
+        open inner class Inner() {
+            open fun result() = s
+        }
+    }
+
+    return Local().Inner().result()
+}
+
+fun main(args : Array<String>) {
+    println(box("OK"))
+}

backend.native/tests/codegen/localClass/localHierarchy.kt

@@ -0,0 +1,15 @@
+fun foo(s: String): String {
+    open class Local {
+        fun f() = s
+    }
+
+    open class Derived: Local() {
+        fun g() = f()
+    }
+
+    return Derived().g()
+}
+
+fun main(args: Array<String>) {
+    println(foo("OK"))
+}

backend.native/tests/codegen/localClass/objectExpressionInInitializer.kt

@@ -0,0 +1,25 @@
+abstract class Father {
+    abstract inner class InClass {
+        abstract fun work(): String
+    }
+}
+
+class Child : Father() {
+    val ChildInClass : InClass
+
+    init {
+        ChildInClass =  object : Father.InClass() {
+            override fun work(): String {
+                return "OK"
+            }
+        }
+    }
+}
+
+fun box(): String {
+    return Child().ChildInClass.work()
+}
+
+fun main(args: Array<String>) {
+    println(box())
+}

backend.native/tests/codegen/localClass/objectExpressionInProperty.kt

@@ -0,0 +1,21 @@
+abstract class Father {
+    abstract inner class InClass {
+        abstract fun work(): String
+    }
+}
+
+class Child : Father() {
+    val ChildInClass = object : Father.InClass() {
+        override fun work(): String {
+            return "OK"
+        }
+    }
+}
+
+fun box(): String {
+    return Child().ChildInClass.work()
+}
+
+fun main(args: Array<String>) {
+    println(box())
+}

backend.native/tests/external/codegen/blackbox/innerNested/superConstructorCall/innerExtendsOuter.kt

@@ -6,7 +6,7 @@
 
 open class Outer(vararg val chars: Char) {
     open inner class Inner(val s: String): Outer(s[0], s[1]) {
-        fun concat() = java.lang.String.valueOf(chars)
+        fun concat() = fromCharArrays(chars, 0, chars.size)
     }
 
     fun value() = Inner("OK").concat()