[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
@@ -13,7 +13,7 @@ fun text() {
    <!INAPPLICABLE_CANDIDATE!>bar2<!> {}
    bar2 {1}
    bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    <!INAPPLICABLE_CANDIDATE!>bar2<!> {it -> it}
+    bar2 {it -> <!ARGUMENT_TYPE_MISMATCH!>it<!>}
 }

 fun bar(f :  (Int, Int) -> Int) {}
@@ -2,9 +2,9 @@
 fun foo(u : Unit) : Int = 1

 fun test() : Int {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(1)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    val a : () -> Unit = {
-        <!INAPPLICABLE_CANDIDATE!>foo<!>(1)
+        foo(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    }
    return 1 <!NONE_APPLICABLE!>-<!> "1"
 }
@@ -23,7 +23,7 @@ fun f(): Unit {
    x !== 1

    x<!NONE_APPLICABLE!>..<!>2
-    x <!INAPPLICABLE_CANDIDATE!>in<!> 1..2
+    <!ARGUMENT_TYPE_MISMATCH!>x<!> in 1..2

    val y : Boolean? = true
    false || y
@@ -29,25 +29,25 @@ fun test() {
    checkSubtype<Double>(1e5)
    checkSubtype<Float>(1e-5.toFloat())

-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Double>(1)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Float>(1)
+    checkSubtype<Double>(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+    checkSubtype<Float>(<!ARGUMENT_TYPE_MISMATCH!>1<!>)

    1 as Byte
    1 as Int
    0xff as Long

    1.1 as Int
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(1.1)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>1.1<!>)

-    <!INAPPLICABLE_CANDIDATE!>varargByte<!>(0x77, 1, 3, 200, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargShort<!>(0x777, 1, 2, 3, 200000, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargInt<!>(0x77777777, 0x7777777777, 1, 2, 3, 2000000000, 0b111)
+    varargByte(0x77, 1, 3, <!ARGUMENT_TYPE_MISMATCH!>200<!>, 0b111)
+    varargShort(0x777, 1, 2, 3, <!ARGUMENT_TYPE_MISMATCH!>200000<!>, 0b111)
+    varargInt(0x77777777, <!ARGUMENT_TYPE_MISMATCH!>0x7777777777<!>, 1, 2, 3, 2000000000, 0b111)
    varargLong(0x777777777777, 1, 2, 3, 200000, 0b111)
-    <!INAPPLICABLE_CANDIDATE!>varargFloat<!>(1, 1.0, -0.1, 1e4, 1e-4, -1e4)
-    <!INAPPLICABLE_CANDIDATE!>varargDouble<!>(1, 1.0, -0.1, 1e4, 1e-4, -1e4)
+    varargFloat(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>1.0<!>, <!ARGUMENT_TYPE_MISMATCH!>-0.1<!>, <!ARGUMENT_TYPE_MISMATCH!>1e4<!>, <!ARGUMENT_TYPE_MISMATCH!>1e-4<!>, <!ARGUMENT_TYPE_MISMATCH!>-1e4<!>)
+    varargDouble(<!ARGUMENT_TYPE_MISMATCH!>1<!>, 1.0, -0.1, 1e4, 1e-4, -1e4)

    testFun(1.0)
-    <!INAPPLICABLE_CANDIDATE!>testFun<!><Float>(1.0)
+    testFun<Float>(<!ARGUMENT_TYPE_MISMATCH!>1.0<!>)
    testFun(1.0.toFloat())
    testFun<Float>(1.0.toFloat())
 }
@@ -40,8 +40,8 @@ class Example {
    var d by CustomDelegate3()

    fun test() {
-        <!INAPPLICABLE_CANDIDATE!>requireString<!>(a)
-        <!INAPPLICABLE_CANDIDATE!>requireString<!>(aval)
+        requireString(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+        requireString(<!ARGUMENT_TYPE_MISMATCH!>aval<!>)
        requireString(b)
        requireInt(c)
        requireInt(d)
@@ -16,7 +16,7 @@ operator fun String.unaryPlus(): Int = 0
 fun test() {
    requireInt(+ "")
    requireInt(+ Example())
-    <!INAPPLICABLE_CANDIDATE!>requireString<!>(<!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated())
+    requireString(<!ARGUMENT_TYPE_MISMATCH!><!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated()<!>)
 }

 fun requireInt(n: Int) {}
@@ -49,7 +49,7 @@ fun <T> bar(a: Any): T = a as T
 fun <T> foo() {
    foo<<!UNRESOLVED_REFERENCE!>Color.RED<!>>()
    foo<RedAlias>()
-    <!INAPPLICABLE_CANDIDATE!>bar<!><<!UNRESOLVED_REFERENCE!>Color.RED<!>>(Color.RED)
+    bar<<!UNRESOLVED_REFERENCE!>Color.RED<!>>(<!ARGUMENT_TYPE_MISMATCH!>Color.RED<!>)
 }

-fun Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>.foo(entries: Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>> = null!!
+fun Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>.foo(entries: Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>>): Array<<!UNRESOLVED_REFERENCE!>Color.RED<!>> = null!!
@@ -2,6 +2,6 @@ fun bar(doIt: Int.() -> Int) {
    1.doIt()
    1<!UNNECESSARY_SAFE_CALL!>?.<!>doIt()
    val i: Int? = 1
-    i.<!INAPPLICABLE_CANDIDATE!>doIt<!>()
+    <!ARGUMENT_TYPE_MISMATCH!>i<!>.doIt()
    i?.doIt()
 }
@@ -33,8 +33,8 @@ fun main(args : Array<String>) {
    <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)

    args.foo1()(1)
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()<!>("1")
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()<!>("1")
+    args.foo1()(<!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
    <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)

    foo2()({})
@@ -62,8 +62,8 @@ fun <T> test2(t : T)
  t.bar()
 }

-val t1 = <!INAPPLICABLE_CANDIDATE!>test2<!><A>(A())
-val t2 = <!INAPPLICABLE_CANDIDATE!>test2<!><B>(C())
+val t1 = test2<A>(<!ARGUMENT_TYPE_MISMATCH!>A()<!>)
+val t2 = test2<B>(<!ARGUMENT_TYPE_MISMATCH!>C()<!>)
 val t3 = test2<C>(C())

 val <T, B : T> x : Int = 0
@@ -28,7 +28,7 @@ fun test(l : java.util.List<Int>) {
  Collections.emptyList()

  checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
-  Collections.<!INAPPLICABLE_CANDIDATE!>singleton<!><Int>(1.0)
+  Collections.singleton<Int>(<!ARGUMENT_TYPE_MISMATCH!>1.0<!>)

  List<Int>

@@ -36,8 +36,8 @@ fun testLiterals() {
 }

 fun testNotSerializable(l: List<Int>) {
-    <!INAPPLICABLE_CANDIDATE!>use<!>(l)
-    <!INAPPLICABLE_CANDIDATE!>use<!>(N())
+    use(<!ARGUMENT_TYPE_MISMATCH!>l<!>)
+    use(<!ARGUMENT_TYPE_MISMATCH!>N()<!>)
 }

 enum class C {
@@ -10,7 +10,7 @@ fun test() {
    v1()
    v1({})
    v1({}, {})
-    <!INAPPLICABLE_CANDIDATE!>v1<!>({}, 1, {})
+    v1({}, <!ARGUMENT_TYPE_MISMATCH!>1<!>, {})
    v1({}, {}, {it})
    v1({}) <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
    v1 <!VARARG_OUTSIDE_PARENTHESES!>{}<!>
@@ -33,9 +33,9 @@ fun <T> copy3(from : Array<out T>, to : Array<in T>) {}
 fun copy4(from : Array<out Number>, to : Array<in Int>) {}

 fun f(ints: Array<Int>, any: Array<Any>, numbers: Array<Number>) {
-    <!INAPPLICABLE_CANDIDATE!>copy1<!>(ints, any)
+    copy1(<!ARGUMENT_TYPE_MISMATCH!>ints<!>, any)
    copy2(ints, any) //ok
-    <!INAPPLICABLE_CANDIDATE!>copy2<!>(ints, numbers)
+    copy2(ints, <!ARGUMENT_TYPE_MISMATCH!>numbers<!>)
    copy3<Int>(ints, numbers)
    copy4(ints, numbers) //ok
 }
@@ -1,10 +1,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)

-class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
-    class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
+class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> {
+    class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> {
        fun test() {
-            class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
+            class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T>
        }
    }
 }
@@ -1,12 +1,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)

-fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> topFun() = 12
+fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> topFun() = 12

 class SomeClass {
-    fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
+    fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> method() = 12

    fun foo() {
-        fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> innerFun() = 12
+        fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> innerFun() = 12
    }
 }
@@ -3,10 +3,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)

-val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> T.topProp: Int get() = 12
+val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)  T> T.topProp: Int get() = 12

 class SomeClass {
-    val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
+    val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) @A2(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>) T> T.field: Int get() = 12

    fun foo() {
        val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> localVal = 12
@@ -1,6 +1,6 @@
 package test

-<!INAPPLICABLE_CANDIDATE!>@BadAnnotation(1)<!>
+@BadAnnotation(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 object SomeObject

 val some = SomeObject
@@ -11,5 +11,5 @@ enum class MyEnum {
    A
 }

-<!INAPPLICABLE_CANDIDATE!>@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test()<!>)<!>
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, ARGUMENT_TYPE_MISMATCH!>Test()<!>)
 class Test2
@@ -11,5 +11,5 @@ enum class MyEnum {
    A
 }

-<!INAPPLICABLE_CANDIDATE!>@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test()<!>)<!>
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, ARGUMENT_TYPE_MISMATCH!>Test()<!>)
 class Test2
@@ -13,7 +13,7 @@ annotation class Ann
 fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> =  null!!

 fun test2(a: @Ann Array<in @Ann Int>) {
-    val r: Array<in Int?> = <!INAPPLICABLE_CANDIDATE!>f3<!>(a)
+    val r: Array<in Int?> = f3(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
 }


@@ -13,7 +13,7 @@ fun foo() {
        return@l1 103
    }

-    bar <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> {
+    bar @Ann(<!ARGUMENT_TYPE_MISMATCH!>""<!>) {
        104
    }
 }
@@ -8,7 +8,7 @@ annotation class Ann(val x: Int = 6)

@Ann(1) @Ann(2) @Ann(3) private class A @Ann constructor() {
    @Ann(x = 5) fun foo() {
-        1 + @Ann(1) 1 * <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> 6
+        1 + @Ann(1) 1 * @Ann(<!ARGUMENT_TYPE_MISMATCH!>""<!>) 6

        @Ann fun local() {}
    }
@@ -7,7 +7,7 @@ fun foo1() {}
@Anno(x = ["a", "b"], y = "a")
 fun foo2() {}

-<!INAPPLICABLE_CANDIDATE!>@Anno(x = <!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("a")<!>, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("b")<!>)<!>, y = "a")<!>
+@Anno(x = <!ARGUMENT_TYPE_MISMATCH, NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>arrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("a")<!>, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>arrayOf("b")<!>)<!>, y = "a")
 fun foo3() {}

@Anno(x = arrayOf("a", "b"), y = "a")
@@ -12,5 +12,5 @@ class C<T> {
 }

 fun test(a: C<out CharSequence>) {
-    <!INAPPLICABLE_CANDIDATE!>a[1]<!> = 25
+    a[1] = <!ARGUMENT_TYPE_MISMATCH!>25<!>
 }
@@ -14,5 +14,5 @@ class C<T> {
 class Out<out F>

 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a <!INAPPLICABLE_CANDIDATE!>+<!> y
+    a + <!ARGUMENT_TYPE_MISMATCH!>y<!>
 }
@@ -28,10 +28,10 @@ fun test() {
    checkSubtype<() -> String>(r4)

    val r5 = (C)::foo
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><() -> String>(r5)
+    checkSubtype<() -> String>(<!ARGUMENT_TYPE_MISMATCH!>r5<!>)

    val r6 = (test.C)::foo
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><() -> String>(r6)
+    checkSubtype<() -> String>(<!ARGUMENT_TYPE_MISMATCH!>r6<!>)

    val c = C.Companion
    val r7 = c::foo
@@ -9,5 +9,5 @@ fun cr() {}

 fun test() {
    <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, ::<!UNRESOLVED_REFERENCE!>cr<!>)
-    <!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, { })
+    takeIt(42, <!ARGUMENT_TYPE_MISMATCH!>{ }<!>)
 }
@@ -13,5 +13,5 @@ class B : A() {
 fun test() {
    B::foo checkType { _<KFunction2<B, String, String>>() }

-    <!INAPPLICABLE_CANDIDATE!>(B::hashCode)<!>("No.")
+    (B::hashCode)(<!ARGUMENT_TYPE_MISMATCH!>"No."<!>)
 }
@@ -12,16 +12,16 @@ fun foo(): String = ""

 class A {
    fun foo() {}
-    
+
    fun main() {
        val x = ::foo

        checkSubtype<KFunction0<Unit>>(x)

        expectFunction0Unit(x)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction0String<!>(x)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1Unit<!>(x)
-        <!INAPPLICABLE_CANDIDATE!>expectFunction1String<!>(x)
+        expectFunction0String(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+        expectFunction1Unit(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+        expectFunction1String(<!ARGUMENT_TYPE_MISMATCH!>x<!>)

        expectFunction0Unit(::foo)
        expectFunction0String(::foo)
@@ -12,7 +12,7 @@ fun foo(): String = ""

 class A {
    fun foo() {}
-    
+
    fun main() {
        val x = ::foo

@@ -23,8 +23,8 @@ fun <T> test(x: T) {

    baz<Int?, String?>(null, null, ::foo)

-    <!INAPPLICABLE_CANDIDATE!>baz<!><Int, String?>(null, null, ::foo)
-    <!INAPPLICABLE_CANDIDATE!>baz<!><Int?, String>(null, null, ::foo)
+    baz<Int, String?>(<!ARGUMENT_TYPE_MISMATCH!>null<!>, null, ::foo)
+    baz<Int?, String>(null, <!ARGUMENT_TYPE_MISMATCH!>null<!>, ::foo)
    baz(null, "", ::foo)
    baz(1, null, ::foo)
    baz(null, null, ::foo)
@@ -22,15 +22,15 @@ fun test() {
    val base = Base::x
    checkSubtype<KProperty1<Base, Any>>(base)
    checkSubtype<Any>(base.get(A()))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Number>(base.get(B()))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(base.get(C()))
+    checkSubtype<Number>(<!ARGUMENT_TYPE_MISMATCH!>base.get(B())<!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>base.get(C())<!>)

    val a = A::x
    checkSubtype<KProperty1<A, String>>(a)
    checkSubtype<String>(a.get(A()))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Number>(a.<!INAPPLICABLE_CANDIDATE!>get<!>(B()))
+    checkSubtype<Number>(<!ARGUMENT_TYPE_MISMATCH!>a.get(<!ARGUMENT_TYPE_MISMATCH!>B()<!>)<!>)

    val b = B::x
    checkSubtype<KProperty1<B, Number>>(b)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(b.get(C()))
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>b.get(C())<!>)
 }
@@ -13,7 +13,7 @@ fun test() {
    val f = String::countCharacters

    checkSubtype<KProperty1<String, Int>>(f)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty1<String, Int>>(f)
+    checkSubtype<KMutableProperty1<String, Int>>(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
    checkSubtype<Int>(f.get("abc"))
    f.<!UNRESOLVED_REFERENCE!>set<!>("abc", 0)

@@ -11,7 +11,7 @@ fun test() {
    val p = A::foo

    checkSubtype<KProperty1<A, Int>>(p)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty1<A, Int>>(p)
+    checkSubtype<KMutableProperty1<A, Int>>(<!ARGUMENT_TYPE_MISMATCH!>p<!>)
    checkSubtype<Int>(p.get(A()))
    p.get(<!NO_VALUE_FOR_PARAMETER!>)<!>
    p.<!UNRESOLVED_REFERENCE!>set<!>(A(), 239)
@@ -20,9 +20,9 @@ fun testX() {

 fun testY() {
    val yy = ::y
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty0<String>>(yy)
+    checkSubtype<KMutableProperty0<String>>(<!ARGUMENT_TYPE_MISMATCH!>yy<!>)
    checkSubtype<KProperty0<String>>(yy)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty<String>>(yy)
+    checkSubtype<KMutableProperty<String>>(<!ARGUMENT_TYPE_MISMATCH!>yy<!>)
    checkSubtype<KProperty<String>>(yy)
    checkSubtype<KCallable<String>>(yy)

@@ -6,5 +6,5 @@ interface G<T>
 fun test(tr: Tr) {
    val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G?<!>
    // If v is not nullable, there will be a warning on this line:
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v!!)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
 }
@@ -4,5 +4,5 @@ class G<T>

 fun foo(p: <!UNRESOLVED_REFERENCE!>P<!>) {
    val v = p as G?
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v!!)
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
 }
@@ -5,5 +5,5 @@ interface G<T>

 fun test(tr: Tr?) {
    val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v)
-}
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
+}
@@ -5,5 +5,5 @@ interface G<T>

 fun test(tr: Tr?) {
    val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G?<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v!!)
-}
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v!!<!>)
+}
@@ -5,5 +5,5 @@ interface G<T>

 fun test(tr: Tr) {
    val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G<!>
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><G<*>>(v)
-}
+    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
+}
@@ -4,4 +4,4 @@
 interface Tr
 interface G<T>

-fun test(tr: Tr) = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>>(tr)
+fun test(tr: Tr) = checkSubtype<<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>G<!>>(<!ARGUMENT_TYPE_MISMATCH!>tr<!>)
@@ -11,27 +11,27 @@ fun main() {
    join(1, "2")
    join(1, "2", "3")
    join(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, *"2")
+    join(1, *<!ARGUMENT_TYPE_MISMATCH!>"2"<!>)
    join(x = 1, a = "2")
    join(x = *1, a = *"2")
    join(x = 1, a = a)
-    <!INAPPLICABLE_CANDIDATE!>join<!>(x = 1, a = b)
+    join(x = 1, a = <!ARGUMENT_TYPE_MISMATCH!>b<!>)
    join(1, *a)
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, *b)
+    join(1, *<!ARGUMENT_TYPE_MISMATCH!>b<!>)
    join(1, *a, "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, *b, "3")
+    join(1, *<!ARGUMENT_TYPE_MISMATCH!>b<!>, "3")
    join(1, "4", *a, "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, "4", *b, "3")
+    join(1, "4", *<!ARGUMENT_TYPE_MISMATCH!>b<!>, "3")
    join(1, "4", *a)
    join(1, "4", *a, *a, "3")
-    <!INAPPLICABLE_CANDIDATE!>join<!>(1, "4", *a, *b, "3")
+    join(1, "4", *a, *<!ARGUMENT_TYPE_MISMATCH!>b<!>, "3")
    join(a = a, x = 1)
-    <!INAPPLICABLE_CANDIDATE!>join<!>(a = b, x = 1)
+    join(a = <!ARGUMENT_TYPE_MISMATCH!>b<!>, x = 1)
    join(a = a, x = 1)

    joinG<String>(1, "2")
    joinG<String>(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!INAPPLICABLE_CANDIDATE!>joinG<!><String>(1, *"2")
+    joinG<String>(1, *<!ARGUMENT_TYPE_MISMATCH!>"2"<!>)
    joinG<String>(x = 1, a = a)
    joinG<String>(x = 1, a = "2")
    joinG<String>(x = *1, a = *"2")
@@ -44,7 +44,7 @@ fun main() {

    joinG(1, "2")
    joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!INAPPLICABLE_CANDIDATE!>joinG<!>(1, *"2")
+    joinG(1, *<!ARGUMENT_TYPE_MISMATCH!>"2"<!>)
    joinG(x = 1, a = a)
    joinG(x = 1, a = "2")
    joinG(x = *1, a = *"2")
@@ -17,9 +17,9 @@ fun test() {

    foo(<!NAMED_PARAMETER_NOT_FOUND!>r<!> = <!UNRESOLVED_REFERENCE!>xx<!>, i = "", s = "")

-    foo(i = 1, <!ARGUMENT_PASSED_TWICE!>i<!> = 1, s = 11)
+    foo(i = 1, <!ARGUMENT_PASSED_TWICE!>i<!> = 1, s = <!ARGUMENT_TYPE_MISMATCH!>11<!>)

-    <!INAPPLICABLE_CANDIDATE!>foo<!>("", s = 2)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, s = <!ARGUMENT_TYPE_MISMATCH!>2<!>)

    foo(i = "", s = 2, <!TOO_MANY_ARGUMENTS!>33<!>)

@@ -5,3 +5,4 @@ package a {
    public fun foo(/*0*/ i: kotlin.Int, /*1*/ s: kotlin.String): kotlin.Unit
    public fun test(): kotlin.Unit
 }
+
@@ -10,7 +10,7 @@ fun bar(a: Int) {}

 fun test() {
    <!NONE_APPLICABLE!>foo<!>(1, 2)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>("")
+    foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)

    <!NONE_APPLICABLE!>bar<!>(1, 2)
    <!NONE_APPLICABLE!>bar<!>()
@@ -4,9 +4,9 @@ package kt1075
 //KT-1075 No type check for 'in range' condition in 'when' expression

 fun foo(b: String) {
-    if (b <!INAPPLICABLE_CANDIDATE!>in<!> 1..10) {} //type mismatch
+    if (<!ARGUMENT_TYPE_MISMATCH!>b<!> in 1..10) {} //type mismatch
    when (b) {
-        <!INAPPLICABLE_CANDIDATE!>in<!> 1..10 -> 1 //no type mismatch, but it should be here
+        <!ARGUMENT_TYPE_MISMATCH!>in 1..10<!> -> 1 //no type mismatch, but it should be here
        else -> 2
    }
 }
@@ -105,11 +105,11 @@ fun testImplicitCoercion() {
    val g = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
    val h = if (false) 4 else {}

-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (true) {
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (true) {
        4
    } else {
        z = 342
-    })
+    }<!>)
 }

 fun fooWithAnyArg(arg: Any) {}
@@ -7,14 +7,14 @@ fun f1(s: String?) {

 fun f2(s: Number?) {
    if (s is Int);
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(s)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
    if (s as Int == 42);
    checkSubtype<Int>(s)
 }

 fun f3(s: Number?) {
    if (s is Int && s as Int == 42);
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(s)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>s<!>)
 }

 fun f4(s: Int?) {
@@ -1,6 +1,6 @@
 fun f(a: Boolean, b: Int) {}

 fun foo(a: Any) {
-    <!INAPPLICABLE_CANDIDATE!>f<!>(a is Int, a)
+    f(a is Int, <!ARGUMENT_TYPE_MISMATCH!>a<!>)
    1 <!NONE_APPLICABLE!>+<!> a
 }
@@ -5,9 +5,9 @@ fun foo() {
    val x: Int? = null

    if (x != null && bar(x) == 0) bar(bar(x))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
-    if (x == null || bar(x) == 0) bar(<!INAPPLICABLE_CANDIDATE!>bar<!>(x))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+    if (x == null || bar(x) == 0) bar(bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>))
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    if (x is Int && bar(x)*bar(x) == bar(x)) bar(x)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -4,10 +4,10 @@ fun foo() {
    val x: Int? = null
    val a = Array<Int>(3, {0})

-    if (x != null) bar(a[x]) else bar(<!INAPPLICABLE_CANDIDATE!>a[x]<!>)
+    if (x != null) bar(a[x]) else bar(a[<!ARGUMENT_TYPE_MISMATCH!>x<!>])
    bar(a[if (x == null) 0 else x])
-    bar(<!INAPPLICABLE_CANDIDATE!>a[x]<!>)
-    
-    <!INAPPLICABLE_CANDIDATE!>"123"[x]<!>;
+    bar(a[<!ARGUMENT_TYPE_MISMATCH!>x<!>])
+
+    "123"[<!ARGUMENT_TYPE_MISMATCH!>x<!>];
    if (x != null) "123"[x];
 }
@@ -7,7 +7,7 @@ fun foo() {
    if (x != null) bar(a[<!DEBUG_INFO_SMARTCAST!>x<!>]) else bar(a[<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>])
    bar(a[if (x == null) 0 else <!DEBUG_INFO_SMARTCAST!>x<!>])
    bar(a[<!TYPE_MISMATCH!>x<!>])
-    
+
    "123"[<!TYPE_MISMATCH!>x<!>];
    if (x != null) "123"[<!DEBUG_INFO_SMARTCAST!>x<!>];
 }
@@ -6,6 +6,6 @@ fun foo() {
    val x: Int? = null

    bar(1 + (if (x == null) 0 else x))
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (x == null) x else x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>if (x == null) x else x<!>)
    if (x != null) bar(x + x/(x-x*x))
 }
@@ -2,7 +2,7 @@

 fun foo1(x: Number, cond: Boolean): Boolean {
    val result = cond && ((x as Int) == 42)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    return result
 }

@@ -14,7 +14,7 @@ fun foo2(x: Number, cond: Boolean): Boolean {

 fun foo3(x: Number, cond: Boolean): Boolean {
    val result = cond || ((x as Int) == 42)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    return result
 }

@@ -11,6 +11,6 @@ fun elvis(x: Number?): Int {

 fun elvisWithRHSTypeInfo(x: Number?): Any? {
    val result = x ?: x!!
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int?>(x)
+    checkSubtype<Int?>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    return result
 }
@@ -17,14 +17,14 @@ fun foo() {
        if (x == null) bar(x) else bar(x)
        bar(bar(x))
    } else if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        if (x != null) {
            bar(x)
            if (x == null) bar(x)
            if (x == null) bar(x) else bar(x)
            bar(bar(x) + bar(x))
        } else if (x == null) {
-            <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+            bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        }
    }

@@ -4,13 +4,13 @@ fun foo() {
    val x: Int? = null

    do {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    } while (x == null)
    bar(x)
-    
+
    val y: Int? = null
    do {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
    } while (y != null)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
@@ -7,7 +7,7 @@ fun foo() {
        bar(<!TYPE_MISMATCH!>x<!>)
    } while (x == null)
    bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
-    
+
    val y: Int? = null
    do {
        bar(<!TYPE_MISMATCH!>y<!>)
@@ -16,5 +16,5 @@ fun doWhileWithBreak(x: Int?, y0: Int) {
        y++
        if (y > 0) break
    } while (x!! == y)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -5,5 +5,5 @@ fun foo() {

    bar(x ?: 0)
    if (x != null) bar(x ?: x)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -1,23 +1,23 @@
 fun bar(x: Int) = x + 1

 fun f1(x: Int?) {
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
    if (x == null) bar(x!!)
 }

-fun f2(x: Int?) {    
+fun f2(x: Int?) {
    if (x != null) else x!!
 }

-fun f3(x: Int?) {    
+fun f3(x: Int?) {
    if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>) else x!!
 }
-    
-fun f4(x: Int?) {    
+
+fun f4(x: Int?) {
    if (x == null) x!! else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }

-fun f5(x: Int?) {    
+fun f5(x: Int?) {
    if (x == null) else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
@@ -6,18 +6,18 @@ fun f1(x: Int?) {
    if (x == null) <!UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!UNREACHABLE_CODE!>)<!>
 }

-fun f2(x: Int?) {    
+fun f2(x: Int?) {
    if (x != null) else <!ALWAYS_NULL!>x<!>!!
 }

-fun f3(x: Int?) {    
+fun f3(x: Int?) {
    if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>) else <!ALWAYS_NULL!>x<!>!!
 }
-    
-fun f4(x: Int?) {    
+
+fun f4(x: Int?) {
    if (x == null) <!ALWAYS_NULL!>x<!>!! else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }

-fun f5(x: Int?) {    
+fun f5(x: Int?) {
    if (x == null) else bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
@@ -5,7 +5,7 @@ fun foo() {
    val a = Array<Int>(3, {0})

    for (p in a) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        if (x == null) continue
        bar(x)
        for (q in a) {
@@ -15,7 +15,7 @@ fun foo() {
    }

    for (p in a) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        if (x == null) break
        bar(x)
    }
@@ -3,7 +3,7 @@ fun bar(x: Int) = x + 1
 fun foo() {
    val x: Int? = null

-    fun baz() = <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    fun baz() = bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    fun quux() = if (x != null) bar(x) else baz()
    fun quuux() = bar(if (x == null) 0 else x)
 }
@@ -25,7 +25,7 @@ fun ifThenElse(x: Int?) {

 fun ifIs(x: Int?, cond: Boolean) {
    if ((x is Int) == cond) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -6,7 +6,7 @@ fun foo() {
    bar(if (x == null) 0 else x)

    if (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        return
    } else {
        bar(x)
@@ -17,14 +17,14 @@ fun foo() {
    if (y is Int) {
        bar(y)
    } else {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
        return
    }
    bar(y)

    val z: Int? = null
    if (z != null) bar(z)
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>z<!>)
    bar(z!!)
    if (z != null) bar(z<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
 }
@@ -3,7 +3,7 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
    val x: Int? = null

-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    if (x != 2) {
        if (x == null) return
        2<!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!><!SYNTAX!><!>
@@ -16,17 +16,17 @@ fun dataFlowInfoAnd(a: Array<Number>) {
    if (a[15] is Int) { if (a[16] is Int) { if (a[17] is Int) { if (a[18] is Int) { if (a[19] is Int) {
    if (a[20] is Int) { if (a[21] is Int) { if (a[22] is Int) { if (a[23] is Int) { if (a[24] is Int) {
    if (a[25] is Int) { if (a[26] is Int) { if (a[27] is Int) { if (a[28] is Int) { if (a[29] is Int) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(a[0])
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>a[0]<!>)
    } } } } } } } } } } } } } } } } } } } } } } } } } } } } } }
 }

 fun dataFlowInfoOr(a: Array<Number>) {
-    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int || 
-        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int || 
-        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int || 
-        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int || 
-        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int || 
+    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int ||
+        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int ||
+        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int ||
+        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int ||
+        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int ||
        a[50] is Int || a[51] is Int || a[52] is Int || a[53] is Int || a[54] is Int || a[55] is Int || a[56] is Int || a[57] is Int || a[58] is Int || a[59] is Int) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(a[0])
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>a[0]<!>)
    }
 }
@@ -21,11 +21,11 @@ fun dataFlowInfoAnd(a: Array<Number>) {
 }

 fun dataFlowInfoOr(a: Array<Number>) {
-    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int || 
-        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int || 
-        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int || 
-        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int || 
-        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int || 
+    if (a[0] is Int || a[1] is Int || a[2] is Int || a[3] is Int || a[4] is Int || a[5] is Int || a[6] is Int || a[7] is Int || a[8] is Int || a[9] is Int ||
+        a[10] is Int || a[11] is Int || a[12] is Int || a[13] is Int || a[14] is Int || a[15] is Int || a[16] is Int || a[17] is Int || a[18] is Int || a[19] is Int ||
+        a[20] is Int || a[21] is Int || a[22] is Int || a[23] is Int || a[24] is Int || a[25] is Int || a[26] is Int || a[27] is Int || a[28] is Int || a[29] is Int ||
+        a[30] is Int || a[31] is Int || a[32] is Int || a[33] is Int || a[34] is Int || a[35] is Int || a[36] is Int || a[37] is Int || a[38] is Int || a[39] is Int ||
+        a[40] is Int || a[41] is Int || a[42] is Int || a[43] is Int || a[44] is Int || a[45] is Int || a[46] is Int || a[47] is Int || a[48] is Int || a[49] is Int ||
        a[50] is Int || a[51] is Int || a[52] is Int || a[53] is Int || a[54] is Int || a[55] is Int || a[56] is Int || a[57] is Int || a[58] is Int || a[59] is Int) {
        checkSubtype<Int>(<!TYPE_MISMATCH!>a[0]<!>)
    }
@@ -7,7 +7,7 @@ class A {
 fun foo() {
    val x: Int? = null

-    A().<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    A().bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    if (x == null) return
    A().bar(x)
 }
@@ -5,14 +5,14 @@ fun bar(x: Int): Int = x + 1
 fun foo(): Int {
    val x: Int? = null

-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    if (x != null) return x
-    
+
    val y: Int? = null
    if (y == null) return if (y != null) y else y
-    
+
    val z: Int? = null
    if (z != null) return if (z == null) z else z
-    
+
    return z
 }
@@ -7,12 +7,12 @@ fun foo(): Int {

    bar(<!TYPE_MISMATCH!>x<!>)
    if (x != null) return x
-    
+
    val y: Int? = null
    if (y == null) return if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>y<!> != null<!>) y else <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>
-    
+
    val z: Int? = null
    if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z
-    
+
    return <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>
 }
@@ -8,14 +8,14 @@ class Derived : Base() {
    fun foo() {
        val x: Int? = null

-        super.<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
-        this.<!INAPPLICABLE_CANDIDATE!>baz<!>(x)
+        super.bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
+        this.baz(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        if (x == null) return
        super.bar(x)
        this.baz(x)

        val y: Int? = null
        if (y != null) super.bar(this.baz(y))
-        else this.baz(super.<!INAPPLICABLE_CANDIDATE!>bar<!>(y))
+        else this.baz(super.bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>))
    }
 }
@@ -3,7 +3,7 @@ fun bar(x: Int): RuntimeException = RuntimeException(x.toString())
 fun foo() {
    val x: Int? = null

-    if (x == null) throw <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+    if (x == null) throw bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    throw bar(x)
    throw bar(x)
 }
@@ -2,8 +2,8 @@ fun bar(x: Int): Int = x + 1

 fun foo() {
    val x: Int? = null
-    
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+
+    bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    if (x == null) return
    try {
        bar(x)
@@ -2,7 +2,7 @@ fun bar(x: Int): Int = x + 1

 fun foo() {
    val x: Int? = null
-    
+
    bar(<!TYPE_MISMATCH!>x<!>)
    if (x == null) return
    try {
@@ -14,7 +14,7 @@ fun tryCatchFinally(x: Int?) {
    } catch (e: Exception) {
        x!!
    } finally {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+        checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
        x!!
    }
    checkSubtype<Int>(x)
@@ -6,7 +6,7 @@ fun foo(x: Number, y: Int) {
        y -> {}
        else -> {}
    }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }

 fun bar(x: Number) {
@@ -14,7 +14,7 @@ fun bar(x: Number) {
        is Int -> checkSubtype<Int>(x)
        else -> {}
    }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }

 fun whenWithoutSubject(x: Number) {
@@ -22,5 +22,5 @@ fun whenWithoutSubject(x: Number) {
        (x is Int) -> checkSubtype<Int>(x)
        else -> {}
    }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -3,20 +3,20 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
    val x: Int? = null
    while (x == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
    }
    bar(x)
-    
+
    val y: Int? = null
    while (y != null) {
        bar(y)
    }
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
-    
+    bar(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
+
    val z: Int? = null
    while (z == null) {
-        <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
+        bar(<!ARGUMENT_TYPE_MISMATCH!>z<!>)
        break
    }
-    <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
+    bar(<!ARGUMENT_TYPE_MISMATCH!>z<!>)
 }
@@ -6,13 +6,13 @@ fun foo() {
        bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
    }
    bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
-    
+
    val y: Int? = null
    while (y != null) {
        bar(<!DEBUG_INFO_SMARTCAST!>y<!>)
    }
    bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>)
-    
+
    val z: Int? = null
    while (z == null) {
        bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>)
@@ -22,5 +22,5 @@ fun whileWithNoCondition(x: Int?) {
    while (<!SYNTAX!><!>) {
        x!!
    }
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -43,7 +43,7 @@ fun test() {

    val (_, `_`) = A()

-    <!INAPPLICABLE_CANDIDATE!>foo<!>(_, y)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>_<!>, y)

    val (unused, _) = A()
 }
@@ -23,7 +23,7 @@ fun test(mc1: MyClass, mc2: MyClass2) {
    checkSubtype<Double>(c)

    //check no error types
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(a)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(b)
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Boolean>(c)
+    checkSubtype<Boolean>(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
+    checkSubtype<Boolean>(<!ARGUMENT_TYPE_MISMATCH!>b<!>)
+    checkSubtype<Boolean>(<!ARGUMENT_TYPE_MISMATCH!>c<!>)
 }
@@ -11,7 +11,7 @@ fun test() {
    const val <T> a3 = 0
    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
    val <T> a5 by Delegate<Int>()
-    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
+    val <T> a6 by <!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
 }

 class Delegate<F> {
@@ -11,7 +11,7 @@ fun test() {
    const val <T> a3 = 0
    <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
    val <T> a5 by Delegate<Int>()
-    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
+    val <T> a6 by <!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
 }

 class Delegate<F> {
@@ -4,10 +4,10 @@ package foo
 import kotlin.reflect.KProperty

 open class A {
-    val B.w: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
+    val B.w: Int by <!ARGUMENT_TYPE_MISMATCH!>MyProperty()<!>
 }

-val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
+val B.r: Int by <!ARGUMENT_TYPE_MISMATCH!>MyProperty()<!>

 val A.e: Int by MyProperty()

@@ -5,7 +5,7 @@
 import kotlin.reflect.KProperty

 class B {
-    val c by <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)
+    val c by Delegate(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>ag<!>)
 }

 class Delegate<T: Any>(val init: T) {
@@ -5,5 +5,5 @@ object T1 {
    operator fun Long.getValue(receiver: String, p: Any): Double = 1.0

    val String.test1 by 1
-    val test2 by <!INAPPLICABLE_CANDIDATE!>1<!>
+    val test2 by <!ARGUMENT_TYPE_MISMATCH!>1<!>
 }
@@ -10,5 +10,5 @@ object T2 {
    operator fun <T> Foo<T>.getValue(receiver: String, p: Any?): T = TODO()

    val String.test1: String by delegate()
-    val test2: String by <!INAPPLICABLE_CANDIDATE!>delegate<!>()
+    val test2: String by <!ARGUMENT_TYPE_MISMATCH!>delegate()<!>
 }
@@ -13,7 +13,7 @@ fun wrong(arg: Wrong) {}
 class Wrong

 class Right {
-    val prop: () -> Unit by ::<!UNRESOLVED_REFERENCE!>wrong<!>
+    val prop: () -> Unit by <!ARGUMENT_TYPE_MISMATCH, ARGUMENT_TYPE_MISMATCH!>::wrong<!>
 }

 fun box(): String {
@@ -5,7 +5,7 @@ import kotlin.reflect.KProperty
 val Int.a by Delegate(<!NO_THIS!>this<!>)

 class A {
-  val Int.a by <!INAPPLICABLE_CANDIDATE!>Delegate<!>(this)
+  val Int.a by Delegate(<!ARGUMENT_TYPE_MISMATCH!>this<!>)
 }

 class Delegate(i: Int) {
@@ -4,7 +4,7 @@
 import kotlin.reflect.KProperty

 class A {
-  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  var a: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 }

 var aTopLevel: Int by Delegate()
@@ -4,10 +4,10 @@
 import kotlin.reflect.KProperty

 class A {
-  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  var a: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 }

-var aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+var aTopLevel: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>

 class Delegate {
  fun getValue(t: Nothing, p: KProperty<*>): Int {
@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
 class A

 class B {
-  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
+  val b: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate<A>()<!>
 }

-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
+val bTopLevel: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate<A>()<!>

 class C {
  val c: Int by Delegate<C>()
@@ -4,10 +4,10 @@
 import kotlin.reflect.KProperty

 class B {
-  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+  val b: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>
 }

-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
+val bTopLevel: Int by <!ARGUMENT_TYPE_MISMATCH!>Delegate()<!>

 class A

@@ -15,14 +15,14 @@ fun test(i: Int?) {

    val a: Int = l4@ ""
    val b: Int = ("")
-    val c: Int = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>("")
-    val d: Int = <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>("")
+    val c: Int = checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    val d: Int = checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)


-    <!INAPPLICABLE_CANDIDATE!>foo<!>(l4@ "")
-    <!INAPPLICABLE_CANDIDATE!>foo<!>((""))
-    foo(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(""))
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(""))
+    foo(l4@ <!ARGUMENT_TYPE_MISMATCH!>""<!>)
+    foo((<!ARGUMENT_TYPE_MISMATCH!>""<!>))
+    foo(checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>""<!>))
+    foo(<!ARGUMENT_TYPE_MISMATCH!>checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)<!>)

    use(a, b, c, d)
 }
@@ -7,24 +7,24 @@ fun test() {
    fooInt(1 - 1)
    fooInt(1 - 1.toInt())
    fooInt(1 - 1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(1 - 1.toLong())
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toLong()<!>)
    fooInt(1 - 1.toShort())

-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(1 - 1.toShort())
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toInt()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toByte()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toLong()<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toShort()<!>)

-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toByte())
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toInt()<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toByte()<!>)
    fooLong(1 - 1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(1 - 1.toShort())
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toShort()<!>)

-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toInt())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toByte())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toLong())
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(1 - 1.toShort())
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toInt()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toByte()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toLong()<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 - 1.toShort()<!>)
 }
@@ -11,26 +11,26 @@ fun fooShort(p: Short) = p

 fun test() {
    fooInt(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooInt<!>(p2)
+    fooInt(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
    fooInt(p3)
    fooInt(p4)
    fooInt(p5)

-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p1)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
    fooLong(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooLong<!>(p5)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)

-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooShort<!>(p5)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)

-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p1)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p2)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p3)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p4)
-    <!INAPPLICABLE_CANDIDATE!>fooByte<!>(p5)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p2<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p3<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p4<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>p5<!>)
 }
@@ -4,5 +4,5 @@ fun bar() {

 // See exception in KT-13421
 fun foo() {
-    42 <!INAPPLICABLE_CANDIDATE!>and<!> false
+    42 and <!ARGUMENT_TYPE_MISMATCH!>false<!>
 }
--- a/Show More
+++ b/Show More