[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
@@ -15,8 +15,8 @@ class B {
 fun test() {
    if (A.x != null) {
        useInt(A.x)
-        <!INAPPLICABLE_CANDIDATE!>useInt<!>(B.x)
+        useInt(<!ARGUMENT_TYPE_MISMATCH!>B.x<!>)
    }
 }

-fun useInt(i: Int) = i
+fun useInt(i: Int) = i
@@ -19,7 +19,7 @@ fun bar(x: String) = x
 fun test(x: String?): Any {
    val y = My.create()
    val z = x ?: y!!
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
    // !! / ?. is necessary here, because y!! above may not be executed
    y?.hashCode()
    y!!.hashCode()
@@ -7,19 +7,19 @@ class TestWithEquals {
 }

 fun bar(i: Test?) {
-    if (i == null) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+    if (i == null) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
 }

 fun bar(i: TestWithEquals?) {
-    if (i == null) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
-    if (null == i) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+    if (i == null) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
+    if (null == i) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
    when (i) {
-        null -> <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+        null -> foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
    }
 }

 fun gav(i: TestWithEquals?, j: TestWithEquals?) {
    if (j == null) {
-        if (i == j) <!INAPPLICABLE_CANDIDATE!>foo<!>(i)
+        if (i == j) foo(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
    }
 }
@@ -30,7 +30,7 @@ fun test(a: A, b: B, c: C) {

        val k = three(a, b, c)
        checkSubtype<A>(k)
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><B>(k)
+        checkSubtype<B>(<!ARGUMENT_TYPE_MISMATCH!>k<!>)
        val l: Int = three(a, b, c)

        use(d, e, f, g, h, k, l)
@@ -41,11 +41,11 @@ fun <T> foo(t: T, l: MutableList<T>): T = t

 fun testErrorMessages(a: A, ml: MutableList<String>) {
    if (a is B && a is C) {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(a, ml)
+        foo(a, <!ARGUMENT_TYPE_MISMATCH!>ml<!>)
    }

    if(a is C) {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(a, ml)
+        foo(a, <!ARGUMENT_TYPE_MISMATCH!>ml<!>)
    }
 }

@@ -53,7 +53,7 @@ fun rr(s: String?) {
    if (s != null) {
        val l = arrayListOf("", s)
        checkSubtype<MutableList<String>>(l)
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><MutableList<String?>>(l)
+        checkSubtype<MutableList<String?>>(<!ARGUMENT_TYPE_MISMATCH!>l<!>)
    }
 }

@@ -6,10 +6,10 @@ class Test {

    fun bar(a: Test, b: Test) {
        if (a.foo != null) {
-            <!INAPPLICABLE_CANDIDATE!>useInt<!>(b.foo)
+            useInt(<!ARGUMENT_TYPE_MISMATCH!>b.foo<!>)
        }
        if (a.foo != null) {
-            <!INAPPLICABLE_CANDIDATE!>useInt<!>(foo)
+            useInt(<!ARGUMENT_TYPE_MISMATCH!>foo<!>)
        }
        if (this.foo != null) {
            useInt(foo)
@@ -7,6 +7,6 @@ fun foo(a: MutableMap<String, String>, x: String?) {
 }

 fun foo1(a: MutableMap<String, String>, x: String?) {
-    <!INAPPLICABLE_CANDIDATE!>a[x]<!> = x!!
+    a[<!ARGUMENT_TYPE_MISMATCH!>x<!>] = x!!
    a[x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>] = x
 }
@@ -11,14 +11,14 @@ val i: Int? = 1
 class A(val i: Int?) {
    fun testUseFromClass() {
        if (foo.i != null) {
-            <!INAPPLICABLE_CANDIDATE!>useInt<!>(i)
+            useInt(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
        }
    }
 }

 fun testUseFromOtherPackage() {
    if (bar.i != null) {
-        <!INAPPLICABLE_CANDIDATE!>useInt<!>(i)
+        useInt(<!ARGUMENT_TYPE_MISMATCH!>i<!>)
    }
 }

@@ -3,4 +3,4 @@ fun Any?.foo(my: My) = my === this
 class My(val x: Any)

 // my is nullable in brackets because Any?.foo has nullable receiver
-fun foo(my: My?) = my?.x.<!INAPPLICABLE_CANDIDATE!>foo<!>(my)
+fun foo(my: My?) = my?.x.foo(<!ARGUMENT_TYPE_MISMATCH!>my<!>)
@@ -50,7 +50,7 @@ fun conditionalThrowInTry_noSmartcastAfterTryCatch(a: A) {
            throw AssertionError()
        }
    } catch (e: Throwable) {}
-    <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+    takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }

 fun conditionalThrowInTry_rethrow_smartcastAfterTryCatch(a: A) {
@@ -61,7 +61,7 @@ fun conditionalThrowInTry_rethrow_smartcastAfterTryCatch(a: A) {
    } catch (e: Throwable) {
        throw e
    }
-    <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+    takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }

 fun conditionalThrowInTry_rethrow_smartcastAfterTryCatchFinally(a: A) {
@@ -72,7 +72,7 @@ fun conditionalThrowInTry_rethrow_smartcastAfterTryCatchFinally(a: A) {
    } catch (e: Throwable) {
        throw e
    } finally {}
-    <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+    takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }

 fun conditionalThrowInTry_rethrow_noSmartcastInFinally(a: A) {
@@ -83,6 +83,6 @@ fun conditionalThrowInTry_rethrow_noSmartcastInFinally(a: A) {
    } catch (e: Throwable) {
        throw e
    } finally {
-        <!INAPPLICABLE_CANDIDATE!>takeB<!>(a)
+        takeB(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
    }
 }
@@ -6,6 +6,6 @@ public fun foo() {
    var s: Any = "not null"
    if (s is String) {
        s = 42
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(s)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
    }
 }
@@ -6,5 +6,5 @@ fun foo(x: Int, f: () -> Unit, y: Int) {}
 fun bar() {
    var x: Int?
    x = 4
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(x, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, x)
+    foo(x, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -7,5 +7,5 @@ fun bar(s: String): Int {

 fun foo(m: MyClass): Int {
    m.p = "xyz"
-    return <!INAPPLICABLE_CANDIDATE!>bar<!>(m.p)
+    return bar(<!ARGUMENT_TYPE_MISMATCH!>m.p<!>)
 }