Move blackBoxFile() testData to box/ directory

Delete all test methods (and empty test classes), since they'll be
auto-generated

compiler/testData/codegen/box/bridges/delegation.kt

@@ -0,0 +1,11 @@
+trait A<T> {
+    fun foo(): T
+}
+
+class B : A<String> {
+    override fun foo() = "OK"
+}
+
+class C(a: A<String>) : A<String> by a
+
+fun box() = (C(B()) : A<String>).foo()

compiler/testData/codegen/box/bridges/delegationProperty.kt

@@ -0,0 +1,15 @@
+trait A<T> {
+    var result: T
+}
+
+class B(a: A<String>): A<String> by a
+
+fun box(): String {
+    val o = object : A<String> {
+        override var result = "Fail"
+    }
+    val b: A<String> = B(o)
+    b.result = "OK"
+    if (b.result != "OK") return "Fail"
+    return (b : A<String>).result
+}

compiler/testData/codegen/box/bridges/delegationToTraitImpl.kt

@@ -0,0 +1,15 @@
+trait A<T> {
+    fun foo(t: T) = "A"
+}
+
+class Z : A<String>
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("")               != "A" -> "Fail #1"
+        (z : A<String>).foo("") != "A" -> "Fail #2"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/diamond.kt

@@ -0,0 +1,23 @@
+trait A<T, U> {
+    fun foo(t: T, u: U) = "A"
+}
+
+trait B<U> : A<String, U>
+
+trait C<T> : A<T, Int>
+
+class Z : B<Int>, C<String> {
+    override fun foo(t: String, u: Int) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("", 0)                    != "Z" -> "Fail #1"
+        (z : C<String>).foo("", 0)      != "Z" -> "Fail #2"
+        (z : B<Int>).foo("", 0)         != "Z" -> "Fail #3"
+        (z : A<String, Int>).foo("", 0) != "Z" -> "Fail #4"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/kt1939.kt

@@ -0,0 +1,12 @@
+abstract class Foo<T> {
+    fun hello(id: T) = "Hi $id"
+}
+
+trait Tr {
+    fun hello(s : String)
+}
+
+class Bar: Foo<String>(), Tr {
+}
+
+fun box(): String = if (Bar().hello("Reg") == "Hi Reg") "OK" else "Fail"

compiler/testData/codegen/box/bridges/kt1959.kt

@@ -0,0 +1,13 @@
+open class A<T> {
+    open fun f(args : Array<T>) {}
+}
+
+class B(): A<String>() {
+    override fun f(args : Array<String>) {}
+}
+
+fun main(args: Array<String>) {
+    B()
+}
+
+fun box(): String = "OK"

compiler/testData/codegen/box/bridges/kt2498.kt

@@ -0,0 +1,19 @@
+import java.util.ArrayList
+
+open class BaseStringList: ArrayList<String>() {
+}
+
+class StringList: BaseStringList() {
+    public override fun get(index: Int): String {
+        return "StringList.get()"
+    }
+}
+
+fun box(): String {
+    val myStringList = StringList()
+    myStringList.add("first element")
+    if (myStringList.get(0) != "StringList.get()") return "Fail #1"
+    if ((myStringList: BaseStringList).get(0) != "StringList.get()") return "Fail #2"
+    if ((myStringList: ArrayList<String>).get(0) != "StringList.get()") return "Fail #3"
+    return "OK"
+}

compiler/testData/codegen/box/bridges/kt2702.kt

@@ -0,0 +1,14 @@
+open class A<R> {
+    open fun foo(r: R): R {return r}
+}
+
+open class B : A<String>() {
+}
+
+open class C : B() {
+    override fun foo(r: String): String {
+        return super.foo(r) + "K"
+    }
+}
+
+fun box() = C().foo("O")

compiler/testData/codegen/box/bridges/kt2833.kt

@@ -0,0 +1,17 @@
+package test
+
+public trait FunDependencyEdge {
+    val from: FunctionNode
+}
+
+public trait FunctionNode
+
+public class FunctionNodeImpl : FunctionNode
+
+class FunDependencyEdgeImpl(override val from: FunctionNodeImpl): FunDependencyEdge {
+}
+
+fun box(): String {
+    (FunDependencyEdgeImpl(FunctionNodeImpl()) as FunDependencyEdge).from
+    return "OK"
+}

compiler/testData/codegen/box/bridges/kt2920.kt

@@ -0,0 +1,9 @@
+trait Tr<T> {
+    val v: T
+}
+
+class C : Tr<String> {
+    override val v = "OK"
+}
+
+fun box() = C().v

compiler/testData/codegen/box/bridges/longChainOneBridge.kt

@@ -0,0 +1,28 @@
+open class A<T> {
+    open fun foo(t: T) = "A"
+}
+
+open class B<T> : A<T>()
+
+open class C : B<String>() {
+    override fun foo(t: String) = "C"
+}
+
+open class D : C()
+
+class Z : D() {
+    override fun foo(t: String) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("")               != "Z" -> "Fail #1"
+        (z : D).foo("")         != "Z" -> "Fail #2"
+        (z : C).foo("")         != "Z" -> "Fail #3"
+        (z : B<String>).foo("") != "Z" -> "Fail #4"
+        (z : A<String>).foo("") != "Z" -> "Fail #5"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/manyTypeArgumentsSubstitutedSuccessively.kt

@@ -0,0 +1,23 @@
+open class A<T, U, V> {
+    open fun foo(t: T, u: U, v: V) = "A"
+}
+
+open class B<T, V> : A<T, Int, V>()
+
+open class C<V> : B<String, V>()
+
+class Z : C<Double>() {
+    override fun foo(t: String, u: Int, v: Double) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("", 0, 0.0)                            != "Z" -> "Fail #1"
+        (z : C<Double>).foo("", 0, 0.0)              != "Z" -> "Fail #2"
+        (z : B<String, Double>).foo("", 0, 0.0)      != "Z" -> "Fail #3"
+        (z : A<String, Int, Double>).foo("", 0, 0.0) != "Z" -> "Fail #4"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/methodFromTrait.kt

@@ -0,0 +1,16 @@
+trait A<T, U> {
+    fun foo(t: T, u: U) = "A"
+}
+
+class Z<T> : A<T, Int> {
+    override fun foo(t: T, u: Int) = "Z"
+}
+
+fun box(): String {
+    val z = Z<Int>()
+    return when {
+        z.foo(0, 0)                 != "Z" -> "Fail #1"
+        (z : A<Int, Int>).foo(0, 0) != "Z" -> "Fail #2"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/overrideAbstractProperty.kt

@@ -0,0 +1,10 @@
+public abstract class AbstractClass<T> {
+    public abstract val some: T
+}
+
+public class Class: AbstractClass<String>() {
+    public override val some: String
+        get() = "OK"
+}
+
+fun box(): String = Class().some

compiler/testData/codegen/box/bridges/overrideReturnType.kt

@@ -0,0 +1,13 @@
+open class C {
+    open fun f(): Any = "C f"
+}
+
+class D() : C() {
+    override fun f(): String = "D f"
+}
+
+fun box(): String{
+    val d : C = D()
+    if(d.f() != "D f") return "fail f"
+    return "OK"
+}

compiler/testData/codegen/box/bridges/propertyAccessorsWithoutBody.kt

@@ -0,0 +1,15 @@
+open class A<T> {
+    open var x: T = "Fail" as T
+    get
+}
+
+class B : A<String>() {
+    override var x: String = "Fail"
+    set
+}
+
+fun box(): String {
+    val a: A<String> = B()
+    a.x = "OK"
+    return a.x
+}

compiler/testData/codegen/box/bridges/propertyDiamond.kt

@@ -0,0 +1,18 @@
+trait A<O, K> {
+    val o: O
+    val k: K
+}
+
+trait B<K> : A<String, K>
+
+trait C<O> : A<O, String>
+
+class D : B<String>, C<String> {
+    override val o = "O"
+    override val k = "K"
+}
+
+fun box(): String {
+    val a: A<String, String> = D()
+    return a.o + a.k
+}

compiler/testData/codegen/box/bridges/propertyInConstructor.kt

@@ -0,0 +1,11 @@
+trait A<T> {
+    var x: T
+}
+
+class B(override var x: String) : A<String>
+
+fun box(): String {
+    val a: A<String> = B("Fail")
+    a.x = "OK"
+    return a.x
+}

compiler/testData/codegen/box/bridges/propertySetter.kt

@@ -0,0 +1,13 @@
+trait A<T> {
+    var v: T
+}
+
+class B : A<String> {
+    override var v: String = "Fail"
+}
+
+fun box(): String {
+    val a: A<String> = B()
+    a.v = "OK"
+    return a.v
+}

compiler/testData/codegen/box/bridges/simple.kt

@@ -0,0 +1,17 @@
+open class A<T> {
+    open fun foo(t: T) = "A"
+}
+
+class Z : A<String>() {
+    override fun foo(t: String) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("")               != "Z" -> "Fail #1"
+        (z : A<String>).foo("") != "Z" -> "Fail #2"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/simpleEnum.kt

@@ -0,0 +1,20 @@
+trait A<T> {
+    open fun foo(t: T) = "A"
+}
+
+enum class Z(val name: String) : A<String> {
+    Z1 : Z("Z1")
+    Z2 : Z("Z2")
+    override fun foo(t: String) = name
+}
+
+
+fun box(): String {
+    return when {
+        Z.Z1.foo("")               != "Z1" -> "Fail #1"
+        Z.Z2.foo("")               != "Z2" -> "Fail #2"
+        (Z.Z1 : A<String>).foo("") != "Z1" -> "Fail #3"
+        (Z.Z2 : A<String>).foo("") != "Z2" -> "Fail #4"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/simpleGenericMethod.kt

@@ -0,0 +1,17 @@
+open class A<T> {
+    open fun <U> foo(t: T, u: U) = "A"
+}
+
+class Z : A<String>() {
+    override fun <U> foo(t: String, u: U) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("", 0)               != "Z" -> "Fail #1"
+        (z : A<String>).foo("", 0) != "Z" -> "Fail #2"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/simpleObject.kt

@@ -0,0 +1,21 @@
+open class A<T> {
+    open fun foo(t: T) = "A"
+}
+
+object Z : A<String>() {
+    override fun foo(t: String) = "Z"
+}
+
+
+fun box(): String {
+    val z = object : A<String>() {
+        override fun foo(t: String) = "z"
+    }
+    return when {
+        Z.foo("")               != "Z" -> "Fail #1"
+        z.foo("")               != "z" -> "Fail #2"
+        (Z : A<String>).foo("") != "Z" -> "Fail #3"
+        (z : A<String>).foo("") != "z" -> "Fail #4"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/simpleReturnType.kt

@@ -0,0 +1,16 @@
+open class A<T : Number>(val t: T) {
+    open fun foo(): T = t
+}
+
+class Z : A<Int>(17) {
+    override fun foo() = 239
+}
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo()            != 239 -> "Fail #1"
+        (z : A<Int>).foo() != 239 -> "Fail #2"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/simpleUpperBound.kt

@@ -0,0 +1,17 @@
+open class A<T : Number> {
+    open fun foo(t: T) = "A"
+}
+
+class Z : A<Int>() {
+    override fun foo(t: Int) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo(0)            != "Z" -> "Fail #1"
+        (z : A<Int>).foo(0) != "Z" -> "Fail #2"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClass.kt

@@ -0,0 +1,20 @@
+open class A<T> {
+    open fun foo(t: T) = "A"
+}
+
+open class B : A<String>()
+
+class Z : B() {
+    override fun foo(t: String) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("")               != "Z" -> "Fail #1"
+        (z : B).foo("")         != "Z" -> "Fail #2"
+        (z : A<String>).foo("") != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassAbstractFun.kt

@@ -0,0 +1,20 @@
+abstract class A<T> {
+    abstract fun foo(t: T): String
+}
+
+abstract class B : A<String>()
+
+class Z : B() {
+    override fun foo(t: String) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("")               != "Z" -> "Fail #1"
+        (z : B).foo("")         != "Z" -> "Fail #2"
+        (z : A<String>).foo("") != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassBoundedTypeArguments.kt

@@ -0,0 +1,19 @@
+open class A<T : U, U> {
+    open fun foo(t: T, u: U) = "A"
+}
+
+open class B : A<Int, Number>()
+
+class Z : B() {
+    override fun foo(t: Int, u: Number) = "Z"
+}
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo(0, 0)                    != "Z" -> "Fail #1"
+        (z : B).foo(0, 0)              != "Z" -> "Fail #2"
+        (z : A<Int, Number>).foo(0, 0) != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassDelegation.kt

@@ -0,0 +1,17 @@
+trait A<T> {
+    fun id(t: T): T
+}
+
+open class B : A<String> {
+    override fun id(t: String) = t
+}
+
+class C : B()
+
+class D : A<String> by C()
+
+fun box(): String {
+    val d = D()
+    if (d.id("") != "") return "Fail"
+    return (d : A<String>).id("OK")
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassEnum.kt

@@ -0,0 +1,24 @@
+trait A<T> {
+    open fun foo(t: T) = "A"
+}
+
+trait B : A<String>
+
+enum class Z(val name: String) : B {
+    Z1 : Z("Z1")
+    Z2 : Z("Z2")
+    override fun foo(t: String) = name
+}
+
+
+fun box(): String {
+    return when {
+        Z.Z1.foo("")               != "Z1" -> "Fail #1"
+        Z.Z2.foo("")               != "Z2" -> "Fail #2"
+        (Z.Z1 : B).foo("")         != "Z1" -> "Fail #3"
+        (Z.Z2 : B).foo("")         != "Z2" -> "Fail #4"
+        (Z.Z1 : A<String>).foo("") != "Z1" -> "Fail #5"
+        (Z.Z2 : A<String>).foo("") != "Z2" -> "Fail #6"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassGenericMethod.kt

@@ -0,0 +1,20 @@
+open class A<T> {
+    open fun <U> foo(t: T, u: U) = "A"
+}
+
+open class B : A<String>()
+
+class Z : B() {
+    override fun <U> foo(t: String, u: U) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("", 0)               != "Z" -> "Fail #1"
+        (z : B).foo("", 0)         != "Z" -> "Fail #2"
+        (z : A<String>).foo("", 0) != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassObject.kt

@@ -0,0 +1,25 @@
+open class A<T> {
+    open fun foo(t: T) = "A"
+}
+
+open class B : A<String>()
+
+object Z : B() {
+    override fun foo(t: String) = "Z"
+}
+
+
+fun box(): String {
+    val o = object : B() {
+        override fun foo(t: String) = "o"
+    }
+    return when {
+        Z.foo("")               != "Z" -> "Fail #1"
+        o.foo("")               != "o" -> "Fail #2"
+        (Z : B).foo("")         != "Z" -> "Fail #3"
+        (o : B).foo("")         != "o" -> "Fail #4"
+        (Z : A<String>).foo("") != "Z" -> "Fail #5"
+        (o : A<String>).foo("") != "o" -> "Fail #6"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/substitutionInSuperClassProperty.kt

@@ -0,0 +1,12 @@
+open class A<T>(val t: T) {
+    open val foo: T = t
+}
+
+open class B : A<String>("Fail")
+
+class Z : B() {
+    override val foo = "OK"
+}
+
+
+fun box() = (Z() : A<String>).foo

compiler/testData/codegen/box/bridges/substitutionInSuperClassUpperBound.kt

@@ -0,0 +1,20 @@
+open class A<T : Number> {
+    open fun foo(t: T) = "A"
+}
+
+open class B : A<Int>()
+
+class Z : B() {
+    override fun foo(t: Int) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo(0)            != "Z" -> "Fail #1"
+        (z : B).foo(0)      != "Z" -> "Fail #2"
+        (z : A<Int>).foo(0) != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/twoParentsWithDifferentMethodsTwoBridges.kt

@@ -0,0 +1,22 @@
+trait A<T> {
+    fun foo(t: T, u: Int) = "A"
+}
+
+trait B<T, U> {
+    fun foo(t: T, u: U) = "B"
+}
+
+class Z : A<String>, B<String, Int> {
+    override fun foo(t: String, u: Int) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo("", 0)                    != "Z" -> "Fail #1"
+        (z : A<String>).foo("", 0)      != "Z" -> "Fail #2"
+        (z : B<String, Int>).foo("", 0) != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}

compiler/testData/codegen/box/bridges/twoParentsWithTheSameMethodOneBridge.kt

@@ -0,0 +1,22 @@
+trait A<T> {
+    fun foo(t: T) = "A"
+}
+
+trait B<T> {
+    fun foo(t: T) = "B"
+}
+
+class Z : A<Int>, B<Int> {
+    override fun foo(t: Int) = "Z"
+}
+
+
+fun box(): String {
+    val z = Z()
+    return when {
+        z.foo(0)            != "Z" -> "Fail #1"
+        (z : A<Int>).foo(0) != "Z" -> "Fail #2"
+        (z : B<Int>).foo(0) != "Z" -> "Fail #3"
+        else -> "OK"
+    }
+}