Move some tests from boxWithStdlib/ to box/

Move those tests which do not require neither stdlib nor reflect

compiler/testData/codegen/box/callableReference/function/abstractClassMember.kt

@@ -0,0 +1,9 @@
+abstract class A {
+    abstract fun foo(): String
+}
+
+class B : A() {
+    override fun foo() = "OK"
+}
+
+fun box(): String = (A::foo)(B())

compiler/testData/codegen/box/callableReference/function/booleanNotIntrinsic.kt

@@ -0,0 +1,5 @@
+fun box(): String {
+    if ((Boolean::not)(true) != false) return "Fail 1"
+    if ((Boolean::not)(false) != true) return "Fail 2"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/classMemberFromClass.kt

@@ -0,0 +1,11 @@
+class A {
+    fun foo(k: Int) = k
+
+    fun result() = (A::foo)(this, 111)
+}
+
+fun box(): String {
+    val result = A().result()
+    if (result != 111) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/classMemberFromExtension.kt

@@ -0,0 +1,12 @@
+class A {
+    fun o() = 111
+    fun k(k: Int) = k
+}
+
+fun A.foo() = (A::o)(this) + (A::k)(this, 222)
+
+fun box(): String {
+    val result = A().foo()
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelStringNoArgs.kt

@@ -0,0 +1,8 @@
+class A {
+    fun foo() = "OK"
+}
+
+fun box(): String {
+    val x = A::foo
+    return x(A())
+}

compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt

@@ -0,0 +1,8 @@
+class A {
+    fun foo(result: String) = result
+}
+
+fun box(): String {
+    val x = A::foo
+    return x(A(), "OK")
+}

compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt

@@ -0,0 +1,14 @@
+class A {
+    var result = "Fail"
+    
+    fun foo() {
+        result = "OK"
+    }
+}
+
+fun box(): String {
+    val a = A()
+    val x = A::foo
+    x(a)
+    return a.result
+}

compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt

@@ -0,0 +1,14 @@
+class A {
+    var result = "Fail"
+    
+    fun foo(newResult: String) {
+        result = newResult
+    }
+}
+
+fun box(): String {
+    val a = A()
+    val x = A::foo
+    x(a, "OK")
+    return a.result
+}

compiler/testData/codegen/box/callableReference/function/constructorFromTopLevelNoArgs.kt

@@ -0,0 +1,5 @@
+class A {
+    var result = "OK"
+}
+
+fun box() = (::A)().result

compiler/testData/codegen/box/callableReference/function/constructorFromTopLevelOneStringArg.kt

@@ -0,0 +1,3 @@
+class A(val result: String)
+
+fun box() = (::A)("OK").result

compiler/testData/codegen/box/callableReference/function/enumValueOfMethod.kt

@@ -0,0 +1,9 @@
+enum class E {
+    ENTRY
+}
+
+fun box(): String {
+    val f = E::valueOf
+    val result = f("ENTRY")
+    return if (result == E.ENTRY) "OK" else "Fail $result"
+}

compiler/testData/codegen/box/callableReference/function/equalsIntrinsic.kt

@@ -0,0 +1,3 @@
+class A
+
+fun box() = if ((A::equals)(A(), A())) "Fail" else "OK"

compiler/testData/codegen/box/callableReference/function/extensionFromClass.kt

@@ -0,0 +1,7 @@
+class A {
+    fun result() = (A::foo)(this, "OK")
+}
+
+fun A.foo(x: String) = x
+
+fun box() = A().result()

compiler/testData/codegen/box/callableReference/function/extensionFromExtension.kt

@@ -0,0 +1,7 @@
+class A
+
+fun A.foo() = (A::bar)(this, "OK")
+
+fun A.bar(x: String) = x
+
+fun box() = A().foo()

compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelStringNoArgs.kt

@@ -0,0 +1,8 @@
+class A
+
+fun A.foo() = "OK"
+
+fun box(): String {
+    val x = A::foo
+    return x(A())
+}

compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelStringOneStringArg.kt

@@ -0,0 +1,8 @@
+class A
+
+fun A.foo(result: String) = result
+
+fun box(): String {
+    val x = A::foo
+    return x(A(), "OK")
+}

compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitNoArgs.kt

@@ -0,0 +1,14 @@
+class A {
+    var result = "Fail"
+}
+
+fun A.foo() {
+    result = "OK"
+}
+
+fun box(): String {
+    val a = A()
+    val x = A::foo
+    x(a)
+    return a.result
+}

compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt

@@ -0,0 +1,14 @@
+class A {
+    var result = "Fail"
+}
+
+fun A.foo(newResult: String) {
+    result = newResult
+}
+
+fun box(): String {
+    val a = A()
+    val x = A::foo
+    x(a, "OK")
+    return a.result
+}

compiler/testData/codegen/box/callableReference/function/genericMember.kt

@@ -0,0 +1,5 @@
+class A<T>(val t: T) {
+    fun foo(): T = t
+}
+
+fun box() = (A<String>::foo)(A("OK"))

compiler/testData/codegen/box/callableReference/function/innerConstructorFromClass.kt

@@ -0,0 +1,14 @@
+class A {
+    inner class Inner {
+        val o = 111
+        val k = 222
+    }
+    
+    fun result() = (A::Inner)(this).o + (A::Inner)(this).k
+}
+
+fun box(): String {
+    val result = A().result()
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/innerConstructorFromExtension.kt

@@ -0,0 +1,14 @@
+class A {
+    inner class Inner {
+        val o = 111
+        val k = 222
+    }
+}
+
+fun A.foo() = (A::Inner)(this).o + (A::Inner)(this).k
+
+fun box(): String {
+    val result = A().foo()
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/innerConstructorFromTopLevelNoArgs.kt

@@ -0,0 +1,12 @@
+class A {
+    inner class Inner {
+        val o = 111
+        val k = 222
+    }
+}
+
+fun box(): String {
+    val result = (A::Inner)((::A)()).o + (A::Inner)(A()).k
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt

@@ -0,0 +1,9 @@
+class A {
+    inner class Inner(val result: Int)
+}
+
+fun box(): String {
+    val result = (A::Inner)((::A)(), 111).result + (A::Inner)(A(), 222).result
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/javaCollectionsStaticMethod.kt

@@ -0,0 +1,13 @@
+// KT-5123
+
+import java.util.Collections
+import java.util.ArrayList
+
+fun box(): String {
+    val numbers = ArrayList<Int>()
+    numbers.add(1)
+    numbers.add(2)
+    numbers.add(3)
+    (Collections::rotate)(numbers, 1)
+    return if ("$numbers" == "[3, 1, 2]") "OK" else "Fail $numbers"
+}

compiler/testData/codegen/box/callableReference/function/local/captureOuter.kt

@@ -0,0 +1,12 @@
+class Outer {
+    val result = "OK"
+
+    inner class Inner {
+        fun foo() = result
+    }
+}
+
+fun box(): String {
+    val f = Outer.Inner::foo
+    return f(Outer().Inner())
+}

compiler/testData/codegen/box/callableReference/function/local/classMember.kt

@@ -0,0 +1,8 @@
+fun box(): String {
+    class Local {
+        fun foo() = "OK"
+    }
+
+    val ref = Local::foo
+    return ref(Local())
+}

compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt

@@ -0,0 +1,9 @@
+fun box(): String {
+    var result = "Fail"
+
+    fun changeToOK() { result = "OK" }
+
+    val ok = ::changeToOK
+    ok()
+    return result
+}

compiler/testData/codegen/box/callableReference/function/local/constructor.kt

@@ -0,0 +1,7 @@
+fun box(): String {
+    class A {
+        val result = "OK"
+    }
+
+    return (::A)().result
+}

compiler/testData/codegen/box/callableReference/function/local/constructorWithInitializer.kt

@@ -0,0 +1,10 @@
+fun box(): String {
+    class A {
+        var result: String = "Fail";
+        init {
+            result = "OK"
+        }
+    }
+
+    return (::A)().result
+}

compiler/testData/codegen/box/callableReference/function/local/enumExtendsTrait.kt

@@ -0,0 +1,11 @@
+interface Named {
+    val name: String
+}
+
+enum class E : Named {
+    OK
+}
+
+fun box(): String {
+    return E.OK.name
+}

compiler/testData/codegen/box/callableReference/function/local/extension.kt

@@ -0,0 +1,6 @@
+class A
+
+fun box(): String {
+    fun A.foo() = "OK"
+    return (A::foo)(A())
+}

compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt

@@ -0,0 +1,5 @@
+fun box(): String {
+    class A
+    fun A.foo() = "OK"
+    return (A::foo)((::A)())
+}

compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt

@@ -0,0 +1,4 @@
+fun box(): String {
+    fun Int.is42With(that: Int) = this + 2 * that == 42
+    return if ((Int::is42With)(16, 13)) "OK" else "Fail"
+}

compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt

@@ -0,0 +1,11 @@
+class A
+
+fun box(): String {
+    var result = "Fail"
+
+    fun A.ext() { result = "OK" }
+
+    val f = A::ext
+    f(A())
+    return result
+}

compiler/testData/codegen/box/callableReference/function/local/genericMember.kt

@@ -0,0 +1,8 @@
+fun box(): String {
+    class Id<T> {
+        fun invoke(t: T) = t
+    }
+
+    val ref = Id<String>::invoke
+    return ref(Id<String>(), "OK")
+}

compiler/testData/codegen/box/callableReference/function/local/localClassMember.kt

@@ -0,0 +1,11 @@
+fun box(): String {
+    val result = "OK"
+
+    class Local {
+        fun foo() = result
+    }
+
+    val member = Local::foo
+    val instance = Local()
+    return member(instance)
+}

compiler/testData/codegen/box/callableReference/function/local/localLocal.kt

@@ -0,0 +1,10 @@
+fun box(): String {
+    fun foo(): String {
+        fun bar() = "OK"
+        val ref = ::bar
+        return ref()
+    }
+
+    val ref = ::foo
+    return ref()
+}

compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt

@@ -0,0 +1,7 @@
+fun foo(until: Int): String {
+    fun bar(x: Int): String =
+        if (x == until) "OK" else bar(x + 1)
+    return (::bar)(0)
+}
+
+fun box() = foo(10)

compiler/testData/codegen/box/callableReference/function/local/simple.kt

@@ -0,0 +1,4 @@
+fun box(): String {
+    fun foo() = "OK"
+    return (::foo)()
+}

compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt

@@ -0,0 +1,7 @@
+fun box(): String {
+    val result = "OK"
+
+    fun foo() = result
+
+    return (::foo)()
+}

compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt

@@ -0,0 +1,4 @@
+fun box(): String {
+    fun foo(s: String) = s
+    return (::foo)("OK")
+}

compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt

@@ -0,0 +1,15 @@
+var state = 23
+
+fun box(): String {
+    fun incrementState(inc: Int) {
+        state += inc
+    }
+
+    val inc = ::incrementState
+    inc(12)
+    inc(-5)
+    inc(27)
+    inc(-15)
+
+    return if (state == 42) "OK" else "Fail $state"
+}

compiler/testData/codegen/box/callableReference/function/nestedConstructorFromClass.kt

@@ -0,0 +1,14 @@
+class A {
+    class Nested {
+        val o = 111
+        val k = 222
+    }
+    
+    fun result() = (::Nested)().o + (A::Nested)().k
+}
+
+fun box(): String {
+    val result = A().result()
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/nestedConstructorFromTopLevelNoArgs.kt

@@ -0,0 +1,7 @@
+class A {
+    class Nested {
+        val result = "OK"
+    }
+}
+
+fun box() = (A::Nested)().result

compiler/testData/codegen/box/callableReference/function/nestedConstructorFromTopLevelOneStringArg.kt

@@ -0,0 +1,5 @@
+class A {
+    class Nested(val result: String)
+}
+
+fun box() = (A::Nested)("OK").result

compiler/testData/codegen/box/callableReference/function/newArray.kt

@@ -0,0 +1,13 @@
+private fun <T> upcast(value: T): T = value
+
+fun box(): String {
+    upcast<(Int)->ByteArray>(::ByteArray)(10)
+    upcast<(Int)->IntArray>(::IntArray)(10)
+    upcast<(Int)->ShortArray>(::ShortArray)(10)
+    upcast<(Int)->LongArray>(::LongArray)(10)
+    upcast<(Int)->DoubleArray>(::DoubleArray)(10)
+    upcast<(Int)->FloatArray>(::FloatArray)(10)
+    upcast<(Int)->BooleanArray>(::BooleanArray)(10)
+
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/overloadedFun.kt

@@ -0,0 +1,27 @@
+fun foo(): String = "foo1"
+fun foo(i: Int): String = "foo2"
+
+val f1: () -> String = ::foo
+val f2: (Int) -> String = ::foo
+
+fun foo1() {}
+fun foo2(i: Int) {}
+
+fun bar(f: () -> Unit): String = "bar1"
+fun bar(f: (Int) -> Unit): String = "bar2"
+
+fun box(): String {
+    val x1 = f1()
+    if (x1 != "foo1") return "Fail 1: $x1"
+    
+    val x2 = f2(0)
+    if (x2 != "foo2") return "Fail 2: $x2"
+    
+    val y1 = bar(::foo1)
+    if (y1 != "bar1") return "Fail 3: $y1"
+    
+    val y2 = bar(::foo2)
+    if (y2 != "bar2") return "Fail 4: $y2"
+    
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/overloadedFunVsVal.kt

@@ -0,0 +1,18 @@
+import kotlin.reflect.*
+
+class A {
+    val x = 1
+    fun x(): String = "OK"
+}
+
+val f1: KProperty1<A, Int> = A::x
+val f2: (A) -> String = A::x
+
+fun box(): String {
+    val a = A()
+
+    val x1 = f1.get(a)
+    if (x1 != 1) return "Fail 1: $x1"
+
+    return f2(a)
+}

compiler/testData/codegen/box/callableReference/function/privateClassMember.kt

@@ -0,0 +1,7 @@
+class A {
+    private fun foo() = "OK"
+
+    fun bar() = (A::foo)(this)
+}
+
+fun box() = A().bar()

compiler/testData/codegen/box/callableReference/function/sortListOfStrings.kt

@@ -0,0 +1,19 @@
+import java.util.ArrayList
+import java.util.Arrays
+import java.util.Collections
+import java.util.Comparator
+
+fun sort(list: MutableList<String>, comparator: (String, String) -> Int) {
+    Collections.sort(list, object : Comparator<String> {
+        override fun compare(p0: String, p1: String) = comparator(p0, p1)
+    })
+}
+
+fun compare(s1: String, s2: String) = s1.compareTo(s2)
+
+fun box(): String {
+    val l = ArrayList(Arrays.asList("d", "b", "c", "e", "a"))
+    sort(l, ::compare)
+    if (l != Arrays.asList("a", "b", "c", "d", "e")) return "Fail: $l"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/topLevelFromClass.kt

@@ -0,0 +1,11 @@
+fun foo(o: Int, k: Int) = o + k
+
+class A {
+    fun bar() = (::foo)(111, 222)
+}
+
+fun box(): String {
+    val result = A().bar()
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/topLevelFromExtension.kt

@@ -0,0 +1,11 @@
+fun foo(o: Int, k: Int) = o + k
+
+class A
+
+fun A.bar() = (::foo)(111, 222)
+
+fun box(): String {
+    val result = A().bar()
+    if (result != 333) return "Fail $result"
+    return "OK"
+}

compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelStringNoArgs.kt

@@ -0,0 +1,6 @@
+fun foo() = "OK"
+
+fun box(): String {
+    val x = ::foo
+    return x()
+}

compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelStringOneStringArg.kt

@@ -0,0 +1,6 @@
+fun foo(x: String) = x
+
+fun box(): String {
+    val x = ::foo
+    return x("OK")
+}

compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitNoArgs.kt

@@ -0,0 +1,11 @@
+var result = "Fail"
+
+fun foo() {
+    result = "OK"
+}
+
+fun box(): String {
+    val x = ::foo
+    x()
+    return result
+}

compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitOneStringArg.kt

@@ -0,0 +1,11 @@
+var result = "Fail"
+
+fun foo(newResult: String) {
+    result = newResult
+}
+
+fun box(): String {
+    val x = ::foo
+    x("OK")
+    return result
+}

compiler/testData/codegen/box/callableReference/function/traitImplMethodWithClassReceiver.kt

@@ -0,0 +1,11 @@
+interface T {
+    fun foo() = "OK"
+}
+
+class B : T {
+    inner class C {
+        fun bar() = (T::foo)(this@B)
+    }
+}
+
+fun box() = B().C().bar()

compiler/testData/codegen/box/callableReference/function/traitMember.kt

@@ -0,0 +1,9 @@
+interface A {
+    fun foo(): String
+}
+
+class B : A {
+    override fun foo() = "OK"
+}
+
+fun box() = (A::foo)(B())