Merge boxWithJava testData into box, delete BoxWithJava test

compiler/testData/codegen/box/statics/anonymousInitializerIObject.kt

@@ -0,0 +1,11 @@
+object Foo {
+    val bar: String
+
+    init {
+        bar = "OK"
+    }
+}
+
+fun box(): String {
+    return Foo.bar
+}

compiler/testData/codegen/box/statics/anonymousInitializerInClassObject.kt

@@ -0,0 +1,13 @@
+class Foo {
+    companion object {
+        val bar: String
+
+        init {
+            bar = "OK"
+        }
+    }
+}
+
+fun box(): String {
+    return Foo.bar
+}

compiler/testData/codegen/box/statics/fields.kt

@@ -0,0 +1,25 @@
+// FILE: Child.java
+
+class Child extends Parent {
+    public static int b = 3;
+    public static int c = 4;
+}
+
+// FILE: Parent.java
+
+class Parent {
+    public static int a = 1;
+    public static int b = 2;
+}
+
+// FILE: test.kt
+
+fun box(): String {
+    if (Parent.a != 1) return "expected Parent.a == 1"
+    if (Parent.b != 2) return "expected Parent.b == 2"
+    if (Child.a != 1) return "expected Child.a == 1"
+    if (Child.b != 3) return "expected Child.b == 3"
+    if (Child.c != 4) return "expected Child.c == 4"
+
+    return "OK"
+}

compiler/testData/codegen/box/statics/functions.kt

@@ -0,0 +1,33 @@
+// FILE: Child.java
+
+class Child extends Parent {
+    public static String bar() {
+        return "Child.bar";
+    }
+    public static String baz() {
+        return "Child.baz";
+    }
+}
+
+// FILE: Parent.java
+
+class Parent {
+    public static String foo() {
+        return "Parent.foo";
+    }
+    public static String baz() {
+        return "Parent.baz";
+    }
+}
+
+// FILE: test.kt
+
+fun box(): String {
+    if (Parent.foo() != "Parent.foo") return "expected: Parent.foo"
+    if (Parent.baz() != "Parent.baz") return "expected: Parent.baz"
+    if (Child.foo() != "Parent.foo") return "expected: Child.foo() != Parent.foo"
+    if (Child.baz() != "Child.baz") return "expected: Child.baz"
+    if (Child.bar() != "Child.bar") return "expected: Child.bar"
+
+    return "OK"
+}

compiler/testData/codegen/box/statics/hidePrivateByPublic.kt

@@ -0,0 +1,30 @@
+// FILE: Child.java
+
+class Child extends Parent {
+    public static String a = "2";
+    public static String foo() {
+        return "Child.foo()";
+    }
+    public static String foo(int i) {
+        return "Child.foo(int)";
+    }
+}
+
+// FILE: Parent.java
+
+class Parent {
+    private static int a = 1;
+    private static String foo() {
+        return "Parent.foo";
+    }
+}
+
+// FILE: test.kt
+
+fun box(): String {
+    if (Child.a != "2") return "Fail #1"
+    if (Child.foo() != "Child.foo()") return "Fail #2"
+    if (Child.foo(1) != "Child.foo(int)") return "Fail #3"
+
+    return "OK"
+}

compiler/testData/codegen/box/statics/incInClassObject.kt

@@ -0,0 +1,74 @@
+
+class A {
+    companion object {
+        private var r: Int = 1;
+
+        fun test(): Int {
+            r++
+            ++r
+            return r
+        }
+
+        var holder: String = ""
+
+        var r2: Int = 1;
+            get() {
+                holder += "getR2"
+                return field
+            }
+
+        fun test2() : Int {
+            r2++
+            ++r2
+            return r2
+        }
+
+        var r3: Int = 1;
+            set(p: Int) {
+                holder += "setR3"
+                field = p
+            }
+
+        fun test3() : Int {
+            r3++
+            ++r3
+            return r3
+        }
+
+        var r4: Int = 1;
+            get() {
+                holder += "getR4"
+                return field
+            }
+            set(p: Int) {
+                holder += "setR4"
+                field = p
+            }
+
+        fun test4() : Int {
+            r4++
+            holder += ":"
+            ++r4
+            return r4
+        }
+    }
+}
+
+fun box() : String {
+    val p = A.test()
+    if (p != 3) return "fail 1: $p"
+
+    val p2 = A.test2()
+    var holderValue = A.holder
+    if (p2 != 3 || holderValue != "getR2getR2getR2getR2") return "fail 2:  $p2 ${holderValue}"
+
+    A.holder = ""
+    val p3 = A.test3()
+    if (p3 != 3 || A.holder != "setR3setR3") return "fail 3:  $p3 ${A.holder}"
+
+    A.holder = ""
+    val p4 = A.test4()
+    if (p4 != 3 || A.holder != "getR4setR4:getR4setR4getR4getR4") return "fail 4:  $p4 ${A.holder}"
+
+    return "OK"
+}

compiler/testData/codegen/box/statics/incInObject.kt

@@ -0,0 +1,71 @@
+object A {
+    private var r: Int = 1;
+
+    fun test() : Int {
+        r++
+        ++r
+        return r
+    }
+
+    var holder: String = ""
+
+    var r2: Int = 1;
+        get() {
+            holder += "getR2"
+            return field
+        }
+
+    fun test2() : Int {
+        r2++
+        ++r2
+        return r2
+    }
+
+    var r3: Int = 1;
+        set(p: Int) {
+            holder += "setR3"
+            field = p
+        }
+
+    fun test3() : Int {
+        r3++
+        ++r3
+        return r3
+    }
+
+    var r4: Int = 1;
+        get() {
+            holder += "getR4"
+            return field
+        }
+        set(p: Int) {
+            holder += "setR4"
+            field = p
+        }
+
+    fun test4() : Int {
+        r4++
+        holder += ":"
+        ++r4
+        return r4
+    }
+}
+
+fun box() : String {
+    val p = A.test()
+    if (p != 3) return "fail 1: $p"
+
+    val p2 = A.test2()
+    val holderValue = A.holder
+    if (p2 != 3 || holderValue != "getR2getR2getR2getR2") return "fail 2:  $p2 ${holderValue}"
+
+    A.holder = ""
+    val p3 = A.test3()
+    if (p3 != 3 || A.holder != "setR3setR3") return "fail 3:  $p3 ${A.holder}"
+
+    A.holder = ""
+    val p4 = A.test4()
+    if (p4 != 3 || A.holder != "getR4setR4:getR4setR4getR4getR4") return "fail 4:  $p4 ${A.holder}"
+
+    return "OK"
+}

compiler/testData/codegen/box/statics/inheritedPropertyInClassObject.kt

@@ -0,0 +1,13 @@
+open class Bar<T>(val prop: String)
+class Foo {
+    companion object : Bar<Foo>("OK") {
+        val p = Foo.prop
+        val p2 = prop
+        val p3 = this.prop
+    }
+
+    val p4 = Foo.prop
+    val p5 = prop
+}
+
+fun box(): String = Foo.prop

compiler/testData/codegen/box/statics/inheritedPropertyInObject.kt

@@ -0,0 +1,8 @@
+open class Bar<T>(val prop: String)
+object Foo : Bar<Foo>("OK") {
+
+    val p = Foo.prop
+    val p2 = prop
+    val p3 = this.prop
+}
+fun box(): String = Foo.prop

compiler/testData/codegen/box/statics/inlineCallsStaticMethod.kt

@@ -0,0 +1,27 @@
+// FILE: Test.java
+
+public class Test {
+
+    protected String data = "O";
+
+    protected Test() {
+
+    }
+
+    protected static String testStatic() {
+        return "K";
+    }
+
+}
+
+// FILE: test.kt
+
+public inline fun test(): String {
+    val p = object : Test() {}
+    return p.data + Test.testStatic();
+}
+
+
+fun box(): String {
+    return test()
+}

compiler/testData/codegen/box/statics/kt8089.kt

@@ -0,0 +1,21 @@
+class C {
+    companion object {
+        private val s: String
+        private var s2: String
+
+        init {
+            s = "O"
+            s2 = "O"
+        }
+
+        fun foo() = s
+
+        fun foo2() = s2
+
+        fun bar2() { s2 = "K" }
+    }
+}
+
+fun box(): String {
+    return C.foo() + {C.bar2(); C.foo2()}()
+}

compiler/testData/codegen/box/statics/protectedSamConstructor.kt

@@ -0,0 +1,27 @@
+// FILE: JavaClass.java
+
+public class JavaClass {
+
+    public String runZ(Z z) {
+        return z.run("O", "K");
+    }
+
+    protected interface Z {
+        String run(String s1, String s2);
+    }
+}
+
+// FILE: Kotlin.kt
+
+package zzz
+
+import JavaClass
+import JavaClass.Z
+
+class A : JavaClass() {
+    fun test() = runZ(JavaClass.Z {a, b -> a + b})
+}
+
+fun box(): String {
+    return A().test()
+}

compiler/testData/codegen/box/statics/protectedStatic.kt

@@ -0,0 +1,35 @@
+// FILE: First.java
+
+public abstract class First {
+    protected static String TEST = "OK";
+
+    protected static String test() {
+        return TEST;
+    }
+}
+
+// FILE: First.kt
+
+package anotherPackage
+
+import First
+
+class Second : First() {
+    val some = { First.TEST }
+    fun foo() = { First.test() }
+
+    val some2 = { TEST }
+    fun foo2() = { test() }
+}
+
+fun box(): String {
+    if (Second().some.invoke() != "OK") return "fail 1"
+
+    if (Second().foo().invoke() != "OK") return "fail 2"
+
+    if (Second().some2.invoke() != "OK") return "fail 3"
+
+    if (Second().foo2().invoke() != "OK") return "fail 4"
+
+    return "OK"
+}

compiler/testData/codegen/box/statics/protectedStatic2.kt

@@ -0,0 +1,58 @@
+// FILE: Base.java
+
+public class Base {
+
+    protected static String BASE_ONLY = "BASE";
+
+    protected static String baseOnly() {
+        return BASE_ONLY;
+    }
+
+    protected static String TEST = "BASE";
+
+    protected static String test() {
+        return TEST;
+    }
+
+    public static class Derived extends Base {
+        protected static String TEST = "DERIVED";
+
+        protected static String test() {
+            return TEST;
+        }
+    }
+}
+
+// FILE: Kotlin.kt
+
+package anotherPackage
+
+import Base.Derived
+import Base
+
+class Kotlin : Base.Derived() {
+    fun doTest(): String {
+
+        if ({ TEST }() != "DERIVED") return "fail 1"
+        if ({ test() }() != "DERIVED") return "fail 2"
+
+        if ({ Derived.TEST }() != "DERIVED") return "fail 3"
+        if ({ Derived.test() }() != "DERIVED") return "fail 4"
+
+        if ({ Base.TEST }() != "BASE") return "fail 5"
+        if ({ Base.test() }() != "BASE") return "fail 6"
+
+
+        if ({ Base.BASE_ONLY }() != "BASE") return "fail 7"
+        if ({ Base.baseOnly() }() != "BASE") return "fail 8"
+
+        if ({ BASE_ONLY }() != "BASE") return "fail 9"
+        if ({ baseOnly() }() != "BASE") return "fail 10"
+
+        return "OK"
+    }
+}
+
+fun box(): String {
+    return Kotlin().doTest()
+}

compiler/testData/codegen/box/statics/protectedStaticAndInline.kt

@@ -0,0 +1,26 @@
+// FILE: First.java
+
+public abstract class First {
+    protected static String TEST = "O";
+
+    protected static String test() {
+        return "K";
+    }
+}
+
+// FILE: Kotlin.kt
+
+package anotherPackage
+
+import First
+
+class Test : First() {
+
+    inline fun doTest(): String {
+        return TEST + test()
+    }
+}
+
+fun box(): String {
+    return Test().doTest()
+}

compiler/testData/codegen/box/statics/syntheticAccessor.kt

@@ -0,0 +1,12 @@
+object A {
+    private val p = "OK";
+
+    object B {
+        val z = p;
+    }
+
+}
+
+fun box(): String {
+    return A.B.z
+}