[FIR] Good test data fixes (around captured types)

2020-09-10 09:24:45 +03:00
parent c2d9fc469a
commit 4605a65f41
38 changed files with 76 additions and 135 deletions
@@ -14,5 +14,5 @@ class C<T> {
 class Out<out F>

 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a + y
+    a <!INAPPLICABLE_CANDIDATE!>+<!> y
 }
@@ -3,5 +3,5 @@

 fun foo() {
    val f : Function1<*, *> = { x -> x.toString() }
-    f(1)
+    <!INAPPLICABLE_CANDIDATE!>f<!>(1)
 }
@@ -21,7 +21,7 @@ class Inv<T>() {
 fun testInOut() {
    In<String>().f("1");
    (null as In<in String>).f("1")
-    (null as In<*>).f("1") // Wrong Arg
+    (null as In<*>).<!NONE_APPLICABLE!>f<!>("1") // Wrong Arg

    In<String>().f(1);
    (null as In<in String>).f(1)
@@ -37,16 +37,16 @@ fun testInOut() {

    Inv<Int>().f(1)
    (null as Inv<in Int>).f(1)
-    (null as Inv<out Int>).f(1) // !!
-    (null as Inv<*>).f(1) // !!
+    (null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
+    (null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!

    Inv<Int>().inf(1)
    (null as Inv<in Int>).inf(1)
-    (null as Inv<out Int>).inf(1) // !!
-    (null as Inv<*>).inf(1) // !!
+    (null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
+    (null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!

    Inv<Int>().outf()
-    checkSubtype<Int>((null as Inv<in Int>).outf()) // Type mismatch
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>((null as Inv<in Int>).outf()) // Type mismatch
    (null as Inv<out Int>).outf()
    (null as Inv<*>).outf()

@@ -29,9 +29,9 @@ fun main() {
    checkSubtype<Outer<out CharSequence>.Inner>(outer.bar())
    checkSubtype<Outer<out CharSequence>.Inner>(outer.Inner())

-    outer.set(outer.bar())
-    outer.set(outer.Inner())
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.Inner())

    val x: Outer<String>.Inner = factoryString()
-    outer.set(x)
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
 }
@@ -15,18 +15,18 @@ fun <T> mc(): MC<T> = null!!
 fun <T> c(): C<T> = null!!

 fun foo(x: MC<out Open>) {
-    x.addAll(x)
-    x.addAllMC(x)
+    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(x)
+    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(x)

-    x.addAll(mc<Open>())
-    x.addAllMC(mc<Open>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Open>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Open>())

-    x.addAll(mc<Derived>())
-    x.addAllMC(mc<Derived>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Derived>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Derived>())

    x.addAll(c())
    x.addAll(c<Nothing>())

-    x.addAllInv(mc<Open>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAllInv<!>(mc<Open>())
    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(1)
 }
@@ -8,11 +8,11 @@ class Out<out E>
 fun test(x: A<out CharSequence>, y: Out<CharSequence>) {
    with(x) {
        // TODO: this diagnostic could be replaced with TYPE_MISMATCH_DUE_TO_TYPE_PROJECTION
-        "".foo()
-        y.bar()
+        "".<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        y.<!INAPPLICABLE_CANDIDATE!>bar<!>()

        with(y) {
-            bar()
+            <!INAPPLICABLE_CANDIDATE!>bar<!>()
        }
    }
 }
@@ -5,5 +5,5 @@ interface B<E> {
 }

 fun foo(x: B<in CharSequence>, y: A<CharSequence>) {
-    x.foo(y)
+    x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
 }
@@ -1,16 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-// !CHECK_TYPE
-
-class A<T> {
-    fun foo(f: (T) -> Unit) {}
-}
-
-fun test(a: A<out Number>, b: A<in Number>) {
-    a.foo {
-        it checkType { _<Number>() }
-    }
-
-    b.foo {
-        it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !CHECK_TYPE

@@ -14,6 +14,6 @@ fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
    val i = a.foo()
    // TODO: These diagnostic are wrong, type of 'i' --- 'In<Nothing>' is not projected itself,
    // but it's approximation result caused by 'a' projection
-    i.invoke1("")
-    i.invoke2(y)
+    i.<!INAPPLICABLE_CANDIDATE!>invoke1<!>("")
+    i.<!INAPPLICABLE_CANDIDATE!>invoke2<!>(y)
 }
@@ -6,5 +6,5 @@ class A<T> {
 }

 fun test(a: A<out CharSequence>) {
-    a.foo("", "")
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "")
 }
@@ -8,7 +8,7 @@ class A<T> {
 }

 fun test(a: A<out CharSequence>) {
-    a + ""
-    a[1] = ""
-    a[""]
+    a <!INAPPLICABLE_CANDIDATE!>+<!> ""
+    <!INAPPLICABLE_CANDIDATE!>a[1] = ""<!>
+    <!INAPPLICABLE_CANDIDATE!>a[""]<!>
 }
@@ -1,9 +0,0 @@
-// !WITH_NEW_INFERENCE
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-// !CHECK_TYPE
-interface A<T : A<T?>?> {
-    fun foo(): T?
-}
-fun testA(a: A<*>) {
-    a.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<*>?>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !CHECK_TYPE
@@ -1,12 +0,0 @@
-// !CHECK_TYPE
-
-interface Clazz<T> {
-    val t: T
-    fun getSuperClass(): Clazz<in T>
-}
-
-fun test(clazz: Clazz<*>) {
-    clazz.t checkType { _<Any?>() }
-    clazz.getSuperClass() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Clazz<*>>() }
-    clazz.getSuperClass().t checkType { _<Any?>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 interface Clazz<T> {
@@ -10,9 +10,9 @@ class A<T> {
 class Out<out F>

 fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
-    a + y
-    a[1] = y
-    a[y]
+    a <!INAPPLICABLE_CANDIDATE!>+<!> y
+    <!INAPPLICABLE_CANDIDATE!>a[1] = y<!>
+    <!INAPPLICABLE_CANDIDATE!>a[y]<!>

    a + Out<Nothing>()
    a[1] = Out<Nothing>()
@@ -13,15 +13,15 @@ class A<T> {
 }

 fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
-    a.foo1(Out<CharSequence>())
-    a.foo1<Out<CharSequence>>(Out())
+    a.<!INAPPLICABLE_CANDIDATE!>foo1<!>(Out<CharSequence>())
+    a.<!INAPPLICABLE_CANDIDATE!>foo1<!><Out<CharSequence>>(Out())

    a.foo1(Out())
    a.foo1(Out<Nothing>())

-    a.foo2(Inv())
-    a.foo2(Inv<CharSequence>())
-    a.foo2<Inv<CharSequence>>(Inv())
+    a.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv())
+    a.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
+    a.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())

    a.foo3(In())
    a.foo3(In<CharSequence>())
@@ -31,13 +31,13 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
    b.foo1(Out<CharSequence>())
    b.foo1<Out<CharSequence>>(Out())

-    b.foo2(Inv())
-    b.foo2(Inv<CharSequence>())
-    b.foo2<Inv<CharSequence>>(Inv())
+    b.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv())
+    b.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
+    b.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())


-    b.foo3(In<CharSequence>())
-    b.foo3<In<CharSequence>>(In())
+    b.<!INAPPLICABLE_CANDIDATE!>foo3<!>(In<CharSequence>())
+    b.<!INAPPLICABLE_CANDIDATE!>foo3<!><In<CharSequence>>(In())

    b.foo3(In<Any?>())
    b.foo3(In())
@@ -6,8 +6,8 @@ class A<T> {
 }

 fun test(a: A<out CharSequence>, y: Array<out CharSequence>) {
-    a.foo("", "", "")
-    a.foo(*y)
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "", "")
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y)
    // TODO: TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS probably redundant
-    a.foo(*y, "")
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y, "")
 }
@@ -6,5 +6,5 @@ interface Tr<T> {

 fun test(t: Tr<*>) {
    t.v = t
-    t.v checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Tr<*>>() }
+    t.v checkType { _<Tr<*>>() }
 }
@@ -1,12 +0,0 @@
-// !CHECK_TYPE
-
-class A<T> {
-    fun foo(): T = null!!
-}
-
-fun <E> A<E>.bar(): A<in E> = this
-
-fun baz(x: A<out CharSequence>) {
-    x.bar() checkType { _<A<*>>() }
-    x.bar().foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() } // See KT-10448
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 class A<T> {
@@ -1,14 +0,0 @@
-// !CHECK_TYPE
-
-// FILE: A.java
-public class A<T> {
-    public A<T>[] baz() { return null; }
-}
-
-
-// FILE: main.kt
-
-fun foo1(x: A<*>) = x.baz()
-fun foo2(x: A<*>) {
-    x.baz() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out A<*>>>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 // FILE: A.java
@@ -19,6 +19,6 @@ class In<in F> {
 }

 fun test() {
-    A.foo().x() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
-    A.bar().y(null)
+    A.foo().x() checkType { _<Any?>() }
+    A.bar().<!INAPPLICABLE_CANDIDATE!>y<!>(null)
 }
@@ -10,7 +10,7 @@ class C(override val t: Any?) : B<Any?, Any>
 fun f(b: B<*, Any>) {
    val y = b.t
    if (y is String?) {
-        y.length
+        y.<!INAPPLICABLE_CANDIDATE!>length<!>
    }
 }

@@ -7,5 +7,5 @@ class In<in T>() {

 fun test1(x: In<String>): Unit = x.f("1")
 fun test2(x: In<in String>): Unit = x.f("1")
-fun test3(x: <!CONFLICTING_PROJECTION!>In<out String><!>): Unit = x.f("1")
-fun test4(x: In<*>): Unit = x.f("1")
+fun test3(x: <!CONFLICTING_PROJECTION!>In<out String><!>): Unit = x.<!NONE_APPLICABLE!>f<!>("1")
+fun test4(x: In<*>): Unit = x.<!NONE_APPLICABLE!>f<!>("1")
@@ -8,7 +8,7 @@ interface A<R, T: A<R, T>> {

 fun testA(a: A<*, *>) {
    a.r().checkType { _<Any?>() }
-    a.t().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<*, *>>() }
+    a.t().checkType { _<A<*, *>>() }
 }

 interface B<R, T: B<List<R>, T>> {
@@ -1,7 +1,7 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<String>): String {
-    return javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!>("", 1) { s: String -> "" }
+    return javaClass.doSomething("", 1) { s: String -> "" }
 }

 // FILE: JavaClass.java
@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>) {
    val a: String = javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething1<!>("", 1) { p: String -> p }
-    val b: String = javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething2<!>("", 1, true) { p: Int -> p }
+    val b: String = javaClass.doSomething2("", 1, true) { p: Int -> p }
 }

 // FILE: JavaClass.java
@@ -10,6 +10,6 @@ fun test2(x: Map<String, Int>) = check(x)

 fun test3(x: Map<Int, String>) = check(x).size

-fun test4(x: Map<Int, String>) = check(x)["42"]
+fun test4(x: Map<Int, String>) = <!INAPPLICABLE_CANDIDATE!>check(x)["42"]<!>

-fun test5(x: Map<Int, String>) = check(x)[42]
+fun test5(x: Map<Int, String>) = <!INAPPLICABLE_CANDIDATE!>check(x)[42]<!>
@@ -11,6 +11,6 @@ fun <T> listOf(): List<T> = null!!
 // Unresolved reference is ok here:
 // we can't create a substituted signature for type alias constructor
 // since it has 'out' type projection in 'in' position.
-val test1 = BOutIn(listOf(), null!!)
+val test1 = <!INAPPLICABLE_CANDIDATE!>BOutIn<!>(listOf(), null!!)

 val test2 = BInIn(listOf(), null!!)
@@ -3,12 +3,12 @@
 fun test(mc: MutableCollection<out CharSequence>) {
    mc.addAll(mc)

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

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

    mc.addAll(emptyList())
    mc.addAll(emptyList<Nothing>())