[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
@@ -19,5 +19,5 @@ public class Y extends X<String> {

 fun main() {
    checkSubtype<Any>(Y().fooN())
-    Y().<!INAPPLICABLE_CANDIDATE!>barN<!>(null);
+    Y().barN(<!ARGUMENT_TYPE_MISMATCH!>null<!>);
 }
@@ -19,5 +19,5 @@ public class Y extends X<A> {

 fun main() {
    checkSubtype<Any>(Y().fooN())
-    Y().<!INAPPLICABLE_CANDIDATE!>barN<!>(null);
+    Y().barN(<!ARGUMENT_TYPE_MISMATCH!>null<!>);
 }
@@ -2,7 +2,7 @@ import java.util.*
 fun foo() {
    val al = ArrayList<String>()
    al.size
-    al.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    al.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    al.contains("")

    al.remove("")
@@ -10,7 +10,7 @@ fun foo() {

    val hs = HashSet<String>()
    hs.size
-    hs.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    hs.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    hs.contains("")

    hs.remove("")
@@ -18,10 +18,10 @@ fun foo() {

    val hm = HashMap<String, Int>()
    hm.size
-    hm.<!INAPPLICABLE_CANDIDATE!>containsKey<!>(1)
+    hm.containsKey(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    hm.containsKey("")

-    <!INAPPLICABLE_CANDIDATE!>hm[1]<!>
+    hm[<!ARGUMENT_TYPE_MISMATCH!>1<!>]
    hm[""]

    hm.remove("")
@@ -35,32 +35,32 @@ fun foo(
        al: java.util.ArrayList<String>
 ) {
    a.contains("")
-    a.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    a.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in a
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> a
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in a

    b.contains("")
-    b.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    b.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in b
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> b
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in b

    ic.contains("")
-    ic.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    ic.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in ic
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> ic
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in ic

    ka.contains("")
-    ka.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    ka.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in ka
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> ka
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in ka

    kb.contains("")
-    kb.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    kb.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in kb
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> kb
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in kb

    al.contains("")
-    al.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    al.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in al
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> al
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in al
 }
@@ -37,20 +37,20 @@ fun foo(
        cs: Collection<String>, ca: Collection<Any?>
 ) {
    a.containsAll(cs)
-    a.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    a.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)

    b.containsAll(cs)
-    b.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    b.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)

    ic.containsAll(cs)
-    ic.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    ic.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)

    ka.containsAll(cs)
-    ka.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    ka.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)

    kb.containsAll(cs)
-    kb.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    kb.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)

    al.containsAll(cs)
-    al.<!INAPPLICABLE_CANDIDATE!>containsAll<!>(ca)
+    al.containsAll(<!ARGUMENT_TYPE_MISMATCH!>ca<!>)
 }
@@ -18,7 +18,7 @@ fun foo(a: A, ka: KA) {
    1 <!NONE_APPLICABLE!>in<!> a

    ka.contains("")
-    ka.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    ka.contains(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
    "" in ka
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> ka
+    <!ARGUMENT_TYPE_MISMATCH!>1<!> in ka
 }
@@ -12,6 +12,6 @@ fun test(x: List<Int>, y: List<String>) {
    A("", x) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any?>>() }
    A("", y) checkType { _<A<String?>>() }

-    <!INAPPLICABLE_CANDIDATE!>A<!><CharSequence, String>("", x)
+    A<CharSequence, String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
    A<CharSequence, String>("", y)
 }
@@ -14,5 +14,5 @@ fun test(x: List<Int>, y: List<String>) {
    Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }

    Outer<Int>().Inner("", x, 1) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<Int>.Inner<Any>>() }
-    Outer<Int>().<!INAPPLICABLE_CANDIDATE!>Inner<!><CharSequence, String, Int>("", x, 1)
+    Outer<Int>().Inner<CharSequence, String, Int>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>, 1)
 }
@@ -10,7 +10,7 @@ fun test(x: List<Int>, y: List<String>) {
    A("", x) // inferred as Any!
    A("", y)

-    <!INAPPLICABLE_CANDIDATE!>A<!><String>("", x)
+    A<String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)

    A<Any>("", x)
    A<String>("", y)
@@ -10,12 +10,12 @@ public class A {
 class Inv<T>

 fun test(x: Inv<Int>, y: Inv<String>) {
-    <!INAPPLICABLE_CANDIDATE!>A<!>("", x)
+    A("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
    A("", y)

-    <!INAPPLICABLE_CANDIDATE!>A<!><String>("", x)
+    A<String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)

-    <!INAPPLICABLE_CANDIDATE!>A<!><Any>("", x)
+    A<Any>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
    A<String>("", y)
-    <!INAPPLICABLE_CANDIDATE!>A<!><CharSequence>("", y)
+    A<CharSequence>("", <!ARGUMENT_TYPE_MISMATCH!>y<!>)
 }
@@ -10,9 +10,9 @@ public class A<E> {
 // FILE: main.kt

 class B1(x: List<String>) : A<CharSequence>("", x)
-class B2(x: List<Int>) : <!INAPPLICABLE_CANDIDATE!>A<CharSequence><!>("", x)
+class B2(x: List<Int>) : A<CharSequence>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)

 class C : A<CharSequence> {
    constructor(x: List<String>) : super("", x)
-    constructor(x: List<Int>, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>("", x)
+    constructor(x: List<Int>, y: Int) : super("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -13,9 +13,9 @@ public class A<E> {
 // if there is not enough information to infer corresponding arguments
 // May be we could add some special syntax for such arguments
 class B1(x: List<String>) : A<CharSequence>("", x)
-class B2(x: List<Int>) : <!INAPPLICABLE_CANDIDATE!>A<CharSequence><!>("", x)
+class B2(x: List<Int>) : A<CharSequence>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)

 class C : A<CharSequence> {
    constructor(x: List<String>) : super("", x)
-    constructor(x: List<Int>, y: Int) : <!INAPPLICABLE_CANDIDATE!>super<!>("", x)
+    constructor(x: List<Int>, y: Int) : super("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
 }
@@ -11,7 +11,7 @@ fun test(x: List<Int>, y: List<String>) {
    var z: A<Double> = A("", x) // E inferred from expected type
    z = A("", y)

-    z = <!INAPPLICABLE_CANDIDATE!>A<!><Double, String>("", x)
+    z = A<Double, String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)

    z = A<Double, Any>("", x)
    z = A<Double, String>("", y)
@@ -11,8 +11,8 @@ public class J {

 import java.io.Serializable

-fun cloneable(c: Cloneable) = <!INAPPLICABLE_CANDIDATE!>J<!>(c)
+fun cloneable(c: Cloneable) = J(<!ARGUMENT_TYPE_MISMATCH!>c<!>)

-fun serializable(s: Serializable) = <!INAPPLICABLE_CANDIDATE!>J<!>(s)
+fun serializable(s: Serializable) = J(<!ARGUMENT_TYPE_MISMATCH!>s<!>)

 fun <T> both(t: T) where T : Cloneable, T : Serializable = J(t)
@@ -100,7 +100,7 @@ public class SpecializedMap extends AbstractSpecializedMap {
 // FILE: main.kt
 fun foo(x: SpecializedMap) {
    x.containsKey(1)
-    x.<!INAPPLICABLE_CANDIDATE!>containsKey<!>(null)
+    x.containsKey(<!ARGUMENT_TYPE_MISMATCH!>null<!>)

    x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>get<!>(2)
    x.<!NONE_APPLICABLE!>get<!>(null)
@@ -16,12 +16,12 @@ public interface J2 extends J {

 // FILE: main.kt
 fun main() {
-    <!INAPPLICABLE_CANDIDATE!>J<!> { s: String -> s} // should be prohibited, because SAM value parameter has nullable type
+    J { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>} // should be prohibited, because SAM value parameter has nullable type
    J { "" + it<!UNSAFE_CALL!>.<!>length }
    J { null }
    J { it?.length?.toString() }

-    <!INAPPLICABLE_CANDIDATE!>J2<!> { s: String -> s}
+    J2 { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>}
    J2 { "" + it<!UNSAFE_CALL!>.<!>length }
    J2 { null }
    J2 { it?.length?.toString() }
@@ -48,6 +48,6 @@ fun main() {
        x -> x.toString()
    }

-    A.<!INAPPLICABLE_CANDIDATE!>baz<!>(block)
+    A.baz(<!ARGUMENT_TYPE_MISMATCH!>block<!>)
    A.baz(block2)
 }
@@ -33,8 +33,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 {
@@ -18,7 +18,7 @@ public interface SLRUMap<V> {
 // FILE: main.kt

 fun <V> SLRUMap<V>.getOrPut(value: V, l: List<V>) {
-    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
+    takeV(<!ARGUMENT_TYPE_MISMATCH!>value<!>)
    takeVList(l)

    takeE(value)
@@ -18,7 +18,7 @@ public interface SLRUMap<V> {
 // FILE: main.kt

 fun <V> SLRUMap<V>.getOrPut(value: V, l: List<V>) {
-    <!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
+    takeV(<!ARGUMENT_TYPE_MISMATCH!>value<!>)
    takeVList(l)

    takeE(value)
@@ -20,5 +20,5 @@ class In<in F> {

 fun test() {
    A.foo().x() checkType { _<Any?>() }
-    A.bar().<!INAPPLICABLE_CANDIDATE!>y<!>(null)
+    A.bar().y(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
 }