[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

2021-04-06 01:35:30 +03:00
parent 4ffab5fe5a
commit ad9b962536
461 changed files with 1239 additions and 1246 deletions
@@ -3,12 +3,12 @@
 fun test(mc: MutableCollection<out CharSequence>) {
    mc.addAll(mc)

-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(arrayListOf<CharSequence>())
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>arrayListOf<CharSequence>()<!>)
    mc.addAll(arrayListOf())

-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf(""))
-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf<String>(""))
-    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf<CharSequence>(""))
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>listOf("")<!>)
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>listOf<String>("")<!>)
+    mc.addAll(<!ARGUMENT_TYPE_MISMATCH!>listOf<CharSequence>("")<!>)

    mc.addAll(emptyList())
    mc.addAll(emptyList<Nothing>())
@@ -6,7 +6,7 @@ annotation class Ann(val i: IntArray)
@Ann(intArrayOf(i2))
@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(<!INAPPLICABLE_CANDIDATE!>intArrayOf<!>(intArrayOf(i, i2, i3)))
+@Ann(intArrayOf(<!ARGUMENT_TYPE_MISMATCH!>intArrayOf(i, i2, i3)<!>))
 class Test

 var i = 1
@@ -6,6 +6,6 @@ public @interface A {
 }

 // FILE: b.kt
-<!INAPPLICABLE_CANDIDATE!>@A(*arrayOf(1, "b"))<!>
+@A(*<!ARGUMENT_TYPE_MISMATCH!>arrayOf(1, "b")<!>)
 fun test() {
 }
@@ -2,6 +2,6 @@

 annotation class B(vararg val args: String)

-<!INAPPLICABLE_CANDIDATE!>@B(*arrayOf(1, "b"))<!>
+@B(*<!ARGUMENT_TYPE_MISMATCH!>arrayOf(1, "b")<!>)
 fun test() {
 }
@@ -14,7 +14,7 @@ class MyClass1
@Ann1(arrayOf(Any::class))
 class MyClass1a

-<!INAPPLICABLE_CANDIDATE!>@Ann1(arrayOf(B1::class))<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(B1::class)<!>)
 class MyClass2

 annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -25,5 +25,5 @@ class MyClass3
@Ann2(arrayOf(B1::class))
 class MyClass4

-<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(B2::class))<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(B2::class)<!>)
 class MyClass5
@@ -11,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
@Ann1(arrayOf(A::class))
 class MyClass1

-<!INAPPLICABLE_CANDIDATE!>@Ann1(arrayOf(Any::class))<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(Any::class)<!>)
 class MyClass1a

@Ann1(arrayOf(B1::class))
@@ -19,11 +19,11 @@ class MyClass2

 annotation class Ann2(val arg: Array<KClass<out B1>>)

-<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(A::class))<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(A::class)<!>)
 class MyClass3

@Ann2(arrayOf(B1::class))
 class MyClass4

-<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(B2::class))<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>arrayOf(B2::class)<!>)
 class MyClass5
@@ -12,7 +12,7 @@ class MyClass1
@Ann1(Any::class)
 class MyClass1a

-<!INAPPLICABLE_CANDIDATE!>@Ann1(B1::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>B1::class<!>)
 class MyClass2

 annotation class Ann2(val arg: KClass<in B1>)
@@ -23,5 +23,5 @@ class MyClass3
@Ann2(B1::class)
 class MyClass4

-<!INAPPLICABLE_CANDIDATE!>@Ann2(B2::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>B2::class<!>)
 class MyClass5
@@ -9,7 +9,7 @@ annotation class Ann1(val arg: KClass<out A>)
@Ann1(A::class)
 class MyClass1

-<!INAPPLICABLE_CANDIDATE!>@Ann1(Any::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>Any::class<!>)
 class MyClass1a

@Ann1(B1::class)
@@ -17,11 +17,11 @@ class MyClass2

 annotation class Ann2(val arg: KClass<out B1>)

-<!INAPPLICABLE_CANDIDATE!>@Ann2(A::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>A::class<!>)
 class MyClass3

@Ann2(B1::class)
 class MyClass4

-<!INAPPLICABLE_CANDIDATE!>@Ann2(B2::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>B2::class<!>)
 class MyClass5
@@ -8,15 +8,15 @@ annotation class Ann1(val arg: KClass<A>)
@Ann1(A::class)
 class MyClass1

-<!INAPPLICABLE_CANDIDATE!>@Ann1(Any::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>Any::class<!>)
 class MyClass1a

-<!INAPPLICABLE_CANDIDATE!>@Ann1(B::class)<!>
+@Ann1(<!ARGUMENT_TYPE_MISMATCH!>B::class<!>)
 class MyClass2

 annotation class Ann2(val arg: KClass<B>)

-<!INAPPLICABLE_CANDIDATE!>@Ann2(A::class)<!>
+@Ann2(<!ARGUMENT_TYPE_MISMATCH!>A::class<!>)
 class MyClass3

@Ann2(B::class)
@@ -6,8 +6,8 @@ public @interface A {
 }

 // FILE: b.kt
-<!INAPPLICABLE_CANDIDATE!>@A(false,
+@A(<!ARGUMENT_TYPE_MISMATCH!>false<!>,
 1.0,
-false)<!> fun foo1() {}
+false) fun foo1() {}

-<!INAPPLICABLE_CANDIDATE!>@A(2.0, x = true, b = 2.0)<!> fun foo2() {}
+@A(<!ARGUMENT_TYPE_MISMATCH!>2.0<!>, x = true, b = 2.0) fun foo2() {}
@@ -14,6 +14,6 @@ fun <T> myRun(block: () -> T): T {
 fun foo(x: Int): Int = x + 1

 fun typeMismatchInLambda(y: String): Int {
-    val x = myRun { <!INAPPLICABLE_CANDIDATE!>foo<!>(y) }
+    val x = myRun { foo(<!ARGUMENT_TYPE_MISMATCH!>y<!>) }
    return x
 }
@@ -1,7 +1,7 @@
 fun main(x1: Double?, range: ClosedRange<Double>) {
    when (x1) {
        null -> throw Exception()
-        <!INAPPLICABLE_CANDIDATE!>in<!> range -> {} // error, no smartcast from previous branch, OK in OI
+        <!ARGUMENT_TYPE_MISMATCH!>in range<!> -> {} // error, no smartcast from previous branch, OK in OI
    }

    when {
@@ -11,24 +11,24 @@ fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()

 val test1 = generate {
    apply {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(4)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>4<!>)
    }
 }

 val test2 = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>(B)
+    yield(<!ARGUMENT_TYPE_MISMATCH!>B<!>)
    apply {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(C)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>C<!>)
    }
 }

 val test3 = generate {
    this.let {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(B)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>B<!>)
    }

    apply {
-        <!INAPPLICABLE_CANDIDATE!>yield<!>(C)
+        yield(<!ARGUMENT_TYPE_MISMATCH!>C<!>)
    }
 }

@@ -12,6 +12,6 @@ fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 suspend fun Base.baseExtension() {}

 val test1 = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>("foo")
+    yield(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
    baseExtension()
 }
@@ -14,17 +14,17 @@ fun <S> Builder<S>.extensionAdd(s: S) {}
 suspend fun <S> Builder<S>.safeExtensionAdd(s: S) {}

 val member = build {
-    <!INAPPLICABLE_CANDIDATE!>add<!>(42)
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }

 val memberWithoutAnn = wrongBuild {
-    <!INAPPLICABLE_CANDIDATE!>add<!>(42)
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }

 val extension = build {
-    <!INAPPLICABLE_CANDIDATE!>extensionAdd<!>("foo")
+    extensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
 }

 val safeExtension = build {
-    <!INAPPLICABLE_CANDIDATE!>safeExtensionAdd<!>("foo")
+    safeExtensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
 }
@@ -20,8 +20,8 @@ suspend fun yield() {}

 fun test() {
    builder {
-        <!INAPPLICABLE_CANDIDATE!>send<!>(run {
+        send(<!ARGUMENT_TYPE_MISMATCH!>run {
            yield() // No error but `yield` is not inside "suspension" context actually
-        })
+        }<!>)
    }
 }
@@ -24,7 +24,7 @@ suspend fun foo(x: Int) = flow {

    var newValue = 1
    newValue += listOf<Int>().asSequence().fold(0) { total, next ->
-        <!INAPPLICABLE_CANDIDATE!>call<!>(11)
+        call(<!ARGUMENT_TYPE_MISMATCH!>11<!>)
        total + next
    }
    newValue += listOf<Int>().asSequence().fold(0, fun(total, next): Int { return total + next })
@@ -9,7 +9,7 @@ fun call(x: String) {}
 fun foo(x: Float, y: Float) = {
    var newValue = 1
    newValue += listOf<Int>().asSequence().fold(0) { total, next ->
-        <!INAPPLICABLE_CANDIDATE!>call<!>(11)
+        call(<!ARGUMENT_TYPE_MISMATCH!>11<!>)
        total + next
    }
    newValue += listOf<Int>().asSequence().fold(0, fun(total, next): Int { return total + next })
@@ -26,7 +26,7 @@ fun <T> id(x: T) = x

 fun foo2() = {
    var x = A()
-    x <!INAPPLICABLE_CANDIDATE!>+=<!> { "" }
+    x += { <!ARGUMENT_TYPE_MISMATCH!>""<!> }
    var y = A()
    y += 1
 }
@@ -25,7 +25,7 @@ val member = build {
 }

 val memberWithoutAnn = wrongBuild {
-    <!INAPPLICABLE_CANDIDATE!>add<!>(42)
+    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }

 val extension = build {
@@ -9,5 +9,5 @@ class Controller<T : Number> {
 fun <S : Number> generate(g: suspend Controller<S>.() -> Unit): S = TODO()

 val test = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>("foo")
+    yield(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
 }
@@ -9,7 +9,7 @@ class GenericController<T> {
 fun <S> generate(g: suspend GenericController<S>.(S) -> Unit): S = TODO()

 val test1 = generate {
-    <!INAPPLICABLE_CANDIDATE!>yield<!>(4)
+    yield(<!ARGUMENT_TYPE_MISMATCH!>4<!>)
 }

 val test2 = generate<Int> {
@@ -12,12 +12,12 @@ fun <E> myBuildList(@BuilderInference builderAction: MutableList<E>.() -> Unit)
 fun main() {
    val newList1 = myBuildList {
        addAll(
-            listOf(1).map { <!INAPPLICABLE_CANDIDATE!>Foo<!>(null) }
+            listOf(1).map { Foo(<!ARGUMENT_TYPE_MISMATCH!>null<!>) }
        )
    }

    val newList2 = buildList {
-        addAll(listOf(1,2,3).map{ <!INAPPLICABLE_CANDIDATE!>Foo<!>(null) })
+        addAll(listOf(1,2,3).map{ Foo(<!ARGUMENT_TYPE_MISMATCH!>null<!>) })
    }
 }

@@ -19,7 +19,7 @@ class Controller {
    suspend fun yieldString(value: String) = suspendCoroutineUninterceptedOrReturn<Int> {
        it.resume(1)
        it checkType { _<Continuation<Int>>() }
-        it.<!INAPPLICABLE_CANDIDATE!>resume<!>("")
+        it.resume(<!ARGUMENT_TYPE_MISMATCH!>""<!>)

        // We can return anything here, 'suspendCoroutineUninterceptedOrReturn' is not very type-safe
        // Also we can call resume and then return the value too, but it's still just our problem
@@ -22,7 +22,7 @@ fun test() {
    builder {
        noParams()
        yieldString("abc") checkType { _<Unit>() }
-        <!INAPPLICABLE_CANDIDATE!>yieldString<!>(1) checkType { _<Unit>() }
+        yieldString(<!ARGUMENT_TYPE_MISMATCH!>1<!>) checkType { _<Unit>() }

        await<String> { "123" } checkType { _<String>() }

@@ -7,7 +7,7 @@ fun useFn(fn: () -> Unit) = fn
 fun ambiguous(sfn: suspend () -> Unit) = sfn
 fun ambiguous(fn: () -> Unit) = fn

-fun test1(sfn: suspend () -> Unit) = <!INAPPLICABLE_CANDIDATE!>useFn<!>(sfn)
+fun test1(sfn: suspend () -> Unit) = useFn(<!ARGUMENT_TYPE_MISMATCH!>sfn<!>)
 fun test2(fn: () -> Unit) = useSuspendFn(fn)

 fun test3(sfn: suspend () -> Unit) = useSuspendFn(sfn)
@@ -22,7 +22,7 @@ fun test() {
    builder {
        noParams()
        yieldString("abc") checkType { _<Unit>() }
-        <!INAPPLICABLE_CANDIDATE!>yieldString<!>(1) checkType { _<Unit>() }
+        yieldString(<!ARGUMENT_TYPE_MISMATCH!>1<!>) checkType { _<Unit>() }

        await<String> { "123" } checkType { _<String>() }

@@ -22,5 +22,5 @@ interface TypePredicate : (KotlinType) -> Boolean {

 fun <T : Any?> TypePredicate.expectedTypeFor(keys: Iterable<T>): Map<T, TypePredicate> =
    keys.fold(SmartFMap.emptyMap<T, TypePredicate>()) { map, key ->
-        map.<!INAPPLICABLE_CANDIDATE!>plus<!>(key, this)
+        map.plus(<!ARGUMENT_TYPE_MISMATCH!>key<!>, this)
    }
@@ -21,12 +21,12 @@ fun test(
    invOut.onlyOut(42)
    invOut.onlyOut(1L)

-    invOut.<!INAPPLICABLE_CANDIDATE!>onlyOutUB<!>("str")
+    invOut.onlyOutUB(<!ARGUMENT_TYPE_MISMATCH!>"str"<!>)
    invStar.<!INAPPLICABLE_CANDIDATE!>onlyOutUB<!>(0)
    invOut.onlyOutUB(42)
    invOut.onlyOutUB(1L)

-    invIn.<!INAPPLICABLE_CANDIDATE!>onlyIn<!>("str")
+    invIn.onlyIn(<!ARGUMENT_TYPE_MISMATCH!>"str"<!>)
    invIn.onlyIn(42)
    invIn.onlyIn(1L)
 }
@@ -21,5 +21,5 @@ fun main() {
    // Here, the error should be
    val x2: (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
    val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
-    val x4: (Int) -> Unit = <!INAPPLICABLE_CANDIDATE!>takeSimpleFunction<!>(id<suspend (Int) -> Unit> {}, <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>{}<!>)
+    val x4: (Int) -> Unit = takeSimpleFunction(<!ARGUMENT_TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Int, kotlin.Unit>")!>{}<!>)
 }
@@ -10,7 +10,7 @@ fun <T : Any> T?.sure() : T = this!!
 fun <E> List<*>.toArray(ar: Array<E>): Array<E> = ar

 fun testArrays(ci: List<Int?>, cii: List<Int?>?) {
-    val c1: Array<Int?> = cii.sure().<!INAPPLICABLE_CANDIDATE!>toArray<!>(Array<Int?>)
+    val c1: Array<Int?> = cii.sure().toArray(<!ARGUMENT_TYPE_MISMATCH!>Array<!><Int?>)

    val c2: Array<Int?> = ci.toArray(Array<Int?>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>)

@@ -4,6 +4,6 @@

 class Base<T : T> : HashSet<T>() {
    fun foo() {
-        super.<!INAPPLICABLE_CANDIDATE!>remove<!>("")
+        super.remove(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
    }
 }
@@ -3,7 +3,7 @@ private const val dateRangeEnd: String = "2020-05-01"

 private fun String?.toIconList(): List<String> = when (this) {
    null -> listOf("DATE_IS_NULL")
-    <!INAPPLICABLE_CANDIDATE!>in<!> dateRangeStart..dateRangeEnd -> emptyList()
+    <!ARGUMENT_TYPE_MISMATCH!>in dateRangeStart..dateRangeEnd<!> -> emptyList()
    else -> listOf("DATE_IS_OUT_OF_RANGE")
 }

@@ -6,7 +6,7 @@ class O : Function2<Int, String, Unit> {
 fun test() {
    val a = fun(o: O) {
    }
-    <!INAPPLICABLE_CANDIDATE!>a<!> {}
+    a <!ARGUMENT_TYPE_MISMATCH!>{}<!>
 }

 <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Ext<!> : String.() -> Unit {
@@ -1,7 +1,7 @@
@JvmName(<!NO_VALUE_FOR_PARAMETER!>)<!>
 fun foo() {}

-<!INAPPLICABLE_CANDIDATE!>@JvmName(42)<!>
+@JvmName(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 fun bar() {}

@JvmName("a", <!TOO_MANY_ARGUMENTS!>"b"<!>)
@@ -2,7 +2,7 @@ fun foo(c : Collection<String>) = {
    c.filter{
        val s : String? = bar()
        if (s == null) false // here!
-        <!INAPPLICABLE_CANDIDATE!>zoo<!>(s)
+        zoo(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
    }
 }

@@ -1,6 +1,6 @@
 // KT-45010
 fun foo(map: MutableMap<Int, String>) {
-    map.<!INAPPLICABLE_CANDIDATE!>getOrPut<!>("Not an Int") {
+    map.getOrPut(<!ARGUMENT_TYPE_MISMATCH!>"Not an Int"<!>) {
        "Hello" + " world"
    }
 }
@@ -3,7 +3,7 @@
 fun indexOfMax(a: IntArray): Int? {
    var maxI: Int? = 0
    a.forEachIndexed { i, value ->
-        if (value >= <!INAPPLICABLE_CANDIDATE!>a[maxI]<!>) {
+        if (value >= a[<!ARGUMENT_TYPE_MISMATCH!>maxI<!>]) {
            maxI = i
        }
        else if (value < 0) {
@@ -46,7 +46,7 @@ fun foo(x: List<String>, y: Throwable, z: A3) {

    y.fillInStackTrace() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }

-    HashMap<String, Int>().<!INAPPLICABLE_CANDIDATE!>getOrDefault<!>(Any(), null)
+    HashMap<String, Int>().getOrDefault(<!ARGUMENT_TYPE_MISMATCH!>Any()<!>, null)

    // Falls back to extension in stdlib
    y.printStackTrace()