[FIR-TEST] Add new testdata generated after changes in previous commit

2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
@@ -0,0 +1,37 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+
+fun <T, R> foo(x: T): R = TODO()
+
+fun <T> fooReturnInt(x: T): Int = 1
+fun <T> fooTakeString(x: String): T = TODO()
+
+fun <T, R> bar(x: T, y: R, f: (T) -> R): Pair<T, R> = TODO()
+fun <T, R> baz(f: (T) -> R, g: (T) -> R): Pair<T, R> = TODO()
+
+class Pair<A, B>(val a: A, val b: B)
+
+fun test1() {
+    bar("", 1, ::foo).checkType { _<Pair<String, Int>>() }
+    bar("", 1, ::fooReturnInt).checkType { _<Pair<String, Int>>() }
+    bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
+    bar("", "", ::fooReturnInt).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Pair<String, Any>>() }
+
+    val x: String = bar("", "", ::fooReturnInt)
+
+    baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
+}
+
+fun <T> listOf(): List<T> = TODO()
+fun <T> setOf(): Set<T> = TODO()
+
+fun <T> test2(x: T) {
+    bar(x, x, ::foo).checkType { _<Pair<T, T>>() }
+    bar(x, 1, ::foo).checkType { _<Pair<T, Int>>() }
+    bar(1, x, ::foo).checkType { _<Pair<Int, T>>() }
+
+    bar(listOf<T>(), setOf<T>(), ::foo).checkType { _<Pair<List<T>, Set<T>>> () }
+    bar(listOf<T>(), 1, ::foo).checkType { _<Pair<List<T>, Int>>() }
+    bar(1, listOf<T>(), ::foo).checkType { _<Pair<Int, List<T>>>() }
+}
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Case<T>
+fun <T> test(case: Case<T>) {}
+fun runTest(method: (Case<Any>) -> Unit) {}
+
+fun <T> runTestGeneric(f: (Case<T>) -> Unit) {}
+
+fun test() {
+    runTest(::test)
+    runTestGeneric<Int>(::test)
+}
@@ -0,0 +1,30 @@
+// !LANGUAGE: +SamConversionPerArgument +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: A.java
+
+public class A {
+    public static void invokeLater(Runnable doRun) {
+    }
+}
+
+// FILE: 1.kt
+
+fun <T> foo(t: T, x: (() -> Unit) -> Unit) {}
+
+fun <T> bar(s: T) {}
+fun <T> complex(t: T, f: (T) -> Unit) {}
+
+fun test1() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(1, A::invokeLater) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
+    foo(1, ::bar)
+
+    complex(1, ::bar)
+}
+
+fun <R> test2(x: R) {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(x, A::invokeLater) // KT-24507 SAM conversion accidentally applied to callable reference and incorrectly handled via BE
+    foo(x, ::bar)
+
+    complex(x, ::bar)
+}
@@ -0,0 +1,24 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A1 {
+    fun <T> a1(t: T): Unit {}
+    fun test1(): (String) -> Unit = A1()::a1
+}
+
+class A2 {
+    fun <K, V> a2(key: K): V = TODO()
+
+    fun test1(): (String) -> Unit = A2()::a2
+    fun <T3> test2(): (T3) -> T3 = A2()::a2
+}
+
+class A3<T> {
+    fun <V> a3(key: T): V = TODO()
+
+    fun test1(): (T) -> Int = this::a3
+    fun test2(): (T) -> Unit = A3<T>()::a3
+    fun test3(): (Int) -> String = A3<Int>()::a3
+
+    fun <R> test4(): (R) -> Unit = this::a3
+    fun <R> test5(): (T) -> R = this::a3
+}
@@ -0,0 +1,25 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+
+fun <T> takeFun(f: (T) -> Unit) {}
+fun <T, R> callFun(f: (T) -> R): R = TODO()
+
+fun <T> foo(s: T) {}
+fun <T : Int> fooInt(s: T) {}
+
+open class Wrapper<T>(val value: T)
+fun <T, R : Wrapper<in T>> createWrapper(s: T): R = TODO()
+
+fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
+
+fun test() {
+    takeFun<String>(::foo)
+    <!INAPPLICABLE_CANDIDATE!>takeFun<!><String>(::fooInt)
+
+    callFun<String, Wrapper<String>>(::createWrapper)
+    callFun<Int, Wrapper<Number>>(::createWrapper)
+    callFun<String, Wrapper<*>>(::createWrapper)
+    callFun<String, Wrapper<Int>>(::createWrapper)
+
+    callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
+}
@@ -0,0 +1,31 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+
+class Wrapper
+
+fun <R, S> Wrapper.foo(x: R): S = TODO()
+fun Wrapper.fooIntString(x: Int): String = ""
+fun <T> Wrapper.fooReturnString(x: T): String = ""
+fun <T> Wrapper.fooTakeInt(x: Int): T = TODO()
+
+fun <T, R, S> bar(f: T.(R) -> S): Tripple<T, R, S> = TODO()
+fun <T, R, S> baz(x: T, y: R, z: S, f: T.(R) -> S): Tripple<T, R, S> = TODO()
+
+class Tripple<A, B, C>(val a: A, val b: B, val c: C)
+
+fun test1() {
+    val x: Wrapper.(String) -> Boolean = Wrapper::foo
+    bar<Wrapper, Double, Float>(Wrapper::foo).checkType { _<Tripple<Wrapper, Double, Float>>() }
+    bar(Wrapper::fooIntString).checkType { _<Tripple<Wrapper, Int, String>>() }
+}
+
+fun <T> test2() {
+    bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
+    bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
+    <!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, T, T>(Wrapper::fooReturnString)
+    <!INAPPLICABLE_CANDIDATE!>bar<!><Wrapper, Int, Int>(Wrapper::fooReturnString)
+
+    bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
+    bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }
+}
@@ -0,0 +1,37 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+
+fun <T, R> foo(x: T): R = TODO()
+fun <T, R> bar(x: T, y: R, f: (T) -> R): Pair<T, R?> = TODO()
+
+inline fun <reified T, reified R> baz(x: T, y: R, f: (T) -> R) {}
+
+data class Pair<A, B>(val a: A, val b: B)
+
+fun <T> test(x: T) {
+    bar(1, "", ::foo).checkType { _<Pair<Int, String?>>() }
+    bar(null, "", ::foo).checkType { _<Pair<Nothing?, String?>>() }
+    bar(1, null, ::foo).checkType { _<Pair<Int, Nothing?>>() }
+    bar(null, null, ::foo).checkType { _<Pair<Nothing?, Nothing?>>() }
+    bar(1, x, ::foo).checkType { _<Pair<Int, T?>>() }
+
+    val s1: Pair<Int, String?> = bar(1, "", ::foo)
+    val (a: Int, b: String?) = bar(1, "", ::foo)
+
+    val s2: Pair<Int?, String?> = bar(null, null, ::foo)
+
+    baz<Int?, String?>(null, null, ::foo)
+
+    baz<Int, String?>(null, null, ::foo)
+    baz<Int?, String>(null, null, ::foo)
+    baz(null, "", ::foo)
+    baz(1, null, ::foo)
+    baz(null, null, ::foo)
+
+    val s3: Pair<Int, String?> = bar(null, null, ::foo)
+    val s4: Pair<Int?, String> = bar(null, null, ::foo)
+
+    val s5: Pair<Int, String> = bar(1, "", ::foo)
+    val (a1: Int, b1: String) = bar(1, "", ::foo)
+}
@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// KT-10968 Callable reference: type inference by function return type
+
+fun <T> getT(): T = null!!
+
+fun getString() = ""
+
+fun test() {
+    val a : () -> String = ::getString
+    val b : () -> String = ::getT
+}
@@ -0,0 +1,10 @@
+// KT-11075 NONE_APPLICABLE reported for callable reference to an overloaded generic function with expected type provided
+
+object TestCallableReferences {
+    fun <A> foo(x: A) = x
+    fun <B> foo(x: List<B>) = x
+
+    fun test0(): (String) -> String = TestCallableReferences::foo
+
+    fun <T> test1(): (List<T>) -> List<T> = <!UNRESOLVED_REFERENCE!>TestCallableReferences::foo<!>
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// KT-12286 Strange type is required for generic callable reference
+
+fun <T: Comparable<T>> maxOf(a: T, b: T): T = if (a < b) b else a
+
+fun <T: Comparable<T>> useMaxOf() {
+    val f: (T, T) -> T = ::maxOf
+}
@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+
+fun <T> shuffle(x: List<T>): List<T> = x
+
+fun bar() {
+    val s: (List<String>) -> List<String> = ::shuffle
+}
@@ -0,0 +1,22 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+
+fun foo(i: Int) {}
+fun foo(s: String) {}
+fun <T> id(x: T): T = x
+fun <T> baz(x: T, y: T): T = TODO()
+
+fun test() {
+    val x1: (Int) -> Unit = id(id(::foo))
+    val x2: (Int) -> Unit = baz(id(::foo), ::foo)
+    val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
+    val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
+    val x5: (Double) -> Unit = baz(id(<!UNRESOLVED_REFERENCE!>::foo<!>), id(id(<!UNRESOLVED_REFERENCE!>::foo<!>)))
+
+
+    id<(Int) -> Unit>(id(id(<!UNRESOLVED_REFERENCE!>::foo<!>)))
+    id(id<(Int) -> Unit>(::foo))
+    baz<(Int) -> Unit>(id(<!UNRESOLVED_REFERENCE!>::foo<!>), id(id(<!UNRESOLVED_REFERENCE!>::foo<!>)))
+    baz(id(<!UNRESOLVED_REFERENCE!>::foo<!>), id(id<(Int) -> Unit>(::foo)))
+    baz(id(<!UNRESOLVED_REFERENCE!>::foo<!>), id<(Int) -> Unit>(id(::foo)))
+}
@@ -0,0 +1,67 @@
+// !LANGUAGE: -TypeInferenceOnGenericsForCallableReferences
+// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
+
+fun <T> bar(s: T) {}
+fun <T> complex(t: T, f: (T) -> Unit) {}
+fun <T> simple(f: (T) -> Unit) {}
+
+fun test1() {
+    complex(1, ::bar)
+    simple<String>(::bar)
+}
+
+// ---
+
+fun <T> takeFun(f: (T) -> Unit) {}
+fun <T, R> callFun(f: (T) -> R): R = TODO()
+
+fun <T> foo(s: T) {}
+
+open class Wrapper<T>(val value: T)
+fun <T, R : Wrapper<in T>> createWrapper(s: T): R = TODO()
+
+fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
+
+fun test2() {
+    takeFun<String>(::foo)
+
+    callFun<String, Wrapper<String>>(::createWrapper)
+    callFun<Int, Wrapper<Number>>(::createWrapper)
+    callFun<String, Wrapper<*>>(::createWrapper)
+
+    callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
+}
+
+// ---
+
+fun test3() {
+    val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
+    val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)
+}
+
+// ---
+
+class A1 {
+    fun <T> a1(t: T): Unit {}
+    fun test1(): (String) -> Unit = A1()::a1
+}
+
+class A2 {
+    fun <K, V> a2(key: K): V = TODO()
+
+    fun test1(): (String) -> Unit = A2()::a2
+    fun <T3> test2(): (T3) -> T3 = A2()::a2
+}
+
+// ---
+
+fun foo1(x: Int?) {}
+fun foo1(y: String?) {}
+fun foo1(z: Boolean) {}
+
+fun <T> baz1(element: (T) -> Unit): T? = null
+
+fun test4() {
+    val a1: Int? = baz1(::foo1)
+    val a2: String? = baz1(::foo1)
+}
@@ -0,0 +1,23 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+
+fun foo(x: Int?) {}
+fun foo(y: String?) {}
+fun foo(z: Boolean) {}
+
+fun <T> baz(element: (T) -> Unit): T? = null
+
+fun test1() {
+    val a1: Int? = baz(::foo)
+    val a2: String? = baz(::foo)
+    val a3: Boolean? = baz<Boolean>(::foo)
+
+    baz<Int>(::foo).checkType { _<Int?>() }
+    baz<String>(::foo).checkType { _<String?>() }
+    baz<Boolean>(::foo).checkType { _<Boolean?>() }
+
+    val b1: Int = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    val b2: String = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
+    val b3: Boolean = baz(<!UNRESOLVED_REFERENCE!>::foo<!>)
+}
@@ -0,0 +1,22 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+
+fun test() {
+    val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
+    val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)
+
+    val a3: Array<Int.(Int) -> Double> = arrayOf(<!UNRESOLVED_REFERENCE!>Double::plus<!>, <!UNRESOLVED_REFERENCE!>Double::minus<!>)
+    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, <!UNRESOLVED_REFERENCE!>Double::minus<!>)
+    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, <!UNRESOLVED_REFERENCE!>Int::minus<!>)
+}
+
+fun foo(x: Int) {}
+fun foo(y: String) {}
+
+fun <T> bar(x: T, f: (T) -> Unit) {}
+
+fun test2() {
+    bar(1, ::foo)
+    bar("", ::foo)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(1.0, <!UNRESOLVED_REFERENCE!>::foo<!>)
+}
@@ -0,0 +1,23 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+
+fun baz(i: Int) = i
+fun <T> bar(x: T): T = TODO()
+
+fun nullableFun(): ((Int) -> Int)? = null
+
+fun test() {
+    val x1: (Int) -> Int = bar(if (true) <!UNRESOLVED_REFERENCE!>::baz<!> else <!UNRESOLVED_REFERENCE!>::baz<!>)
+    val x2: (Int) -> Int = bar(nullableFun() ?: <!UNRESOLVED_REFERENCE!>::baz<!>)
+    val x3: (Int) -> Int = bar(::baz ?: <!UNRESOLVED_REFERENCE!>::baz<!>)
+
+    val i = 0
+    val x4: (Int) -> Int = bar(when (i) {
+                                   10 -> <!UNRESOLVED_REFERENCE!>::baz<!>
+                                   20 -> <!UNRESOLVED_REFERENCE!>::baz<!>
+                                   else -> <!UNRESOLVED_REFERENCE!>::baz<!>
+                               })
+
+    val x5: (Int) -> Int = bar(<!UNRESOLVED_REFERENCE!>::baz<!>!!)
+
+    <!UNRESOLVED_REFERENCE!>(if (true) <!UNRESOLVED_REFERENCE!>::baz<!> else <!UNRESOLVED_REFERENCE!>::baz<!>)(1)<!>
+}