Refactor ImplementationBodyCodegen.getTraitImplementations()

Make it static, extract a method which finds an implementation in a trait for a fake override
2014-04-08 18:37:02 +04:00
parent 5967befa6a
commit fc838dbb53
16 changed files with 145 additions and 105 deletions
@@ -0,0 +1,15 @@
+open class AL<T> {
+    fun get(index: Int) : T? = null
+}
+
+trait ALE<T> : AL<T> {
+    fun getOrValue(index: Int, value : T) : T = get(index) ?: value
+}
+
+class SmartArrayList() : ALE<String>, AL<String>() {
+}
+
+fun box() : String {
+  val c = SmartArrayList()
+  return if("239" == c.getOrValue(0, "239")) "OK" else "fail"
+}
@@ -0,0 +1,19 @@
+abstract class Base<T> {
+    abstract var s: T
+}
+
+trait Trait<T> : Base<T> {
+    var value : T
+        get() = s
+        set(value) { s = value }
+}
+
+class Derived : Trait<String>, Base<String>() {
+    override var s = "Fail"
+}
+
+fun box(): String {
+    val d = Derived()
+    d.value = "OK"
+    return d.value
+}
@@ -0,0 +1,15 @@
+open class MyClass(param : String) {
+    var propterty = param
+}
+
+trait MyTrait : MyClass
+{
+    fun foo()  = propterty
+}
+
+open class B(param : String) : MyTrait, MyClass(param)
+{
+    override fun foo() = super<MyTrait>.foo()
+}
+
+fun box()= B("OK").foo()
@@ -0,0 +1,15 @@
+open class Base
+
+trait Derived : Base {
+    fun foo(): String {
+        return object {
+            fun bar() = baz(this@Derived)
+        }.bar()
+    }
+}
+
+class DerivedImpl : Derived, Base()
+
+fun baz(b: Base) = "OK"
+
+fun box() = DerivedImpl().foo()
@@ -0,0 +1,9 @@
+trait Trait<T : Enum<T>> : Enum<T> {
+    val value : String get() = name()
+}
+
+enum class E : Trait<E> {
+    OK
+}
+
+fun box() = E.OK.value
@@ -0,0 +1,17 @@
+open class Base {
+    open fun sayHello(): String{
+        return "fail"
+    }
+}
+
+trait Trait: Base {
+    override fun sayHello(): String {
+        return "OK"
+    }
+}
+
+class Derived(): Base(), Trait
+
+fun box() : String {
+    return Derived().sayHello()
+}
@@ -0,0 +1,17 @@
+open class Base {
+    var s = "Fail"
+}
+
+trait Trait : Base {
+    var value : String
+        get() = s
+        set(value) { s = value }
+}
+
+class Derived : Trait, Base()
+
+fun box(): String {
+    val d = Derived()
+    d.value = "OK"
+    return d.value
+}
@@ -0,0 +1,14 @@
+open class Base
+
+trait Trait : Base {
+    private val value : String
+        get() = "OK"
+        
+    override fun toString() = object {
+        fun foo() = value
+    }.foo()
+}
+
+class Derived : Trait, Base()
+
+fun box() = "${Derived()}"
@@ -0,0 +1,12 @@
+trait SimpleClass : java.lang.Object {
+    fun foo() : String = "239 " + toString ()
+}
+
+class SimpleClassImpl() : SimpleClass {
+   override fun toString() = "SimpleClassImpl"
+}
+
+fun box() : String {
+  val c = SimpleClassImpl()
+  return if("239 SimpleClassImpl" == c.foo()) "OK" else "fail"
+}
@@ -0,0 +1,18 @@
+open class Base {
+    open fun foo() : String {
+      return "fail"
+    }
+}
+
+trait Derived : Base {
+    override fun foo() : String {
+        //super.foo()
+        return "OK"
+    }
+}
+
+class DerivedImpl : Derived, Base()
+
+fun box(): String {
+    return DerivedImpl().foo()
+}
@@ -0,0 +1,22 @@
+open class Base {
+    open fun foo() { }
+    open fun foo2() { }
+}
+
+trait Derived : Base {
+    override fun foo() {
+        object {
+            fun bar() {
+                //super<Base>@Derived.foo2()
+                this@Derived.foo2()
+            }
+        }.bar()
+    }
+}
+
+class DerivedImpl : Derived, Base()
+
+fun box(): String {
+    DerivedImpl().foo()
+    return "OK"
+}
@@ -0,0 +1,17 @@
+open class Foo() {
+    public fun k(): String = "K"
+}
+
+
+trait T: Foo {
+    public fun xyzzy(): String = o() + k()
+    public fun o(): String
+}
+
+class TImpl(): Foo(), T {
+    public override fun o(): String = "O"
+}
+
+fun box(): String {
+    return TImpl().xyzzy()
+}