azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Fix tests (ARGUMENT_TYPE_MISMATCH instead of INCOMPATIBLE_CANDIDATE)

Browse Source
This commit is contained in:
Ivan Kochurkin
2021-04-06 01:35:30 +03:00
committed by TeamCityServer
parent 4ffab5fe5a
commit ad9b962536
461 changed files with 1239 additions and 1246 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.fir.kt
Vendored
+8 -8
View File
@@ -15,18 +15,18 @@ fun <T> mc(): MC<T> = null!!
fun <T> c(): C<T> = null!!
fun foo(x: MC<out Open>) {
x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(x)
x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(x)
x.addAll(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
x.addAllMC(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Open>())
x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Open>())
x.addAll(<!ARGUMENT_TYPE_MISMATCH!>mc<Open>()<!>)
x.addAllMC(<!ARGUMENT_TYPE_MISMATCH!>mc<Open>()<!>)
x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Derived>())
x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Derived>())
x.addAll(<!ARGUMENT_TYPE_MISMATCH!>mc<Derived>()<!>)
x.addAllMC(<!ARGUMENT_TYPE_MISMATCH!>mc<Derived>()<!>)
x.addAll(c())
x.addAll(c<Nothing>())
x.<!INAPPLICABLE_CANDIDATE!>addAllInv<!>(mc<Open>())
x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(1)
x.addAllInv(<!ARGUMENT_TYPE_MISMATCH!>mc<Open>()<!>)
x.addAll(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
}
compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.fir.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ interface B<E> {
}
fun foo(x: B<in CharSequence>, y: A<CharSequence>) {
x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
x.foo(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
}
compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.fir.kt
Vendored
+2 -2
View File
@@ -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.<!INAPPLICABLE_CANDIDATE!>invoke1<!>("")
i.<!INAPPLICABLE_CANDIDATE!>invoke2<!>(y)
i.invoke1(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
i.invoke2(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
}
compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ class A<T> {
}
fun test(a: A<out CharSequence>) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "")
a.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
}
compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.fir.kt
Vendored
+3 -3
View File
@@ -8,7 +8,7 @@ class A<T> {
}
fun test(a: A<out CharSequence>) {
a <!INAPPLICABLE_CANDIDATE!>+<!> ""
<!INAPPLICABLE_CANDIDATE!>a[1]<!> = ""
<!INAPPLICABLE_CANDIDATE!>a[""]<!>
a + <!ARGUMENT_TYPE_MISMATCH!>""<!>
a[1] = <!ARGUMENT_TYPE_MISMATCH!>""<!>
a[<!ARGUMENT_TYPE_MISMATCH!>""<!>]
}
compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.fir.kt
Vendored
+4 -4
View File
@@ -6,18 +6,18 @@ class C<R> {
}
fun foo(x: Any?, y: C<*>) {
y.<!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
y.bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
if (x is C<*>) {
x.<!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
x.bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
with(x) {
<!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
}
}
with(x) {
if (this is C<*>) {
<!INAPPLICABLE_CANDIDATE!>bindTo<!>("")
bindTo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
}
}
}
compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ interface A<T>
interface B<T> : A<A<T>>
fun foo(x : B<*>) {
<!INAPPLICABLE_CANDIDATE!>bar1<!>(x) // this should not be valid
bar1(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // this should not be valid
bar2(x)
bar3(x)
}
compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ fun acceptA(a: A) {
fun main(i: I<*>) {
i.foo() checkType { _<A?>() }
<!INAPPLICABLE_CANDIDATE!>acceptA<!>(i.foo()) // i.foo() should be nullable but isn't
acceptA(<!ARGUMENT_TYPE_MISMATCH!>i.foo()<!>) // i.foo() should be nullable but isn't
}
compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.fir.kt
Vendored
+3 -3
View File
@@ -10,9 +10,9 @@ class A<T> {
class Out<out F>
fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
a <!INAPPLICABLE_CANDIDATE!>+<!> y
<!INAPPLICABLE_CANDIDATE!>a[1]<!> = y
<!INAPPLICABLE_CANDIDATE!>a[y]<!>
a + <!ARGUMENT_TYPE_MISMATCH!>y<!>
a[1] = <!ARGUMENT_TYPE_MISMATCH!>y<!>
a[<!ARGUMENT_TYPE_MISMATCH!>y<!>]
a + Out<Nothing>()
a[1] = Out<Nothing>()
compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.fir.kt
Vendored
+8 -8
View File
@@ -13,15 +13,15 @@ class A<T> {
}
fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
a.<!INAPPLICABLE_CANDIDATE!>foo1<!>(Out<CharSequence>())
a.<!INAPPLICABLE_CANDIDATE!>foo1<!><Out<CharSequence>>(Out())
a.foo1(<!ARGUMENT_TYPE_MISMATCH!>Out<CharSequence>()<!>)
a.foo1<Out<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Out()<!>)
a.foo1(Out())
a.foo1(Out<Nothing>())
a.foo2(Inv())
a.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
a.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())
a.foo2(<!ARGUMENT_TYPE_MISMATCH!>Inv<CharSequence>()<!>)
a.foo2<Inv<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)
a.foo3(In())
a.foo3(In<CharSequence>())
@@ -32,12 +32,12 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
b.foo1<Out<CharSequence>>(Out())
b.foo2(Inv())
b.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
b.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())
b.foo2(<!ARGUMENT_TYPE_MISMATCH!>Inv<CharSequence>()<!>)
b.foo2<Inv<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>Inv()<!>)
b.<!INAPPLICABLE_CANDIDATE!>foo3<!>(In<CharSequence>())
b.<!INAPPLICABLE_CANDIDATE!>foo3<!><In<CharSequence>>(In())
b.foo3(<!ARGUMENT_TYPE_MISMATCH!>In<CharSequence>()<!>)
b.foo3<In<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>In()<!>)
b.foo3(In<Any?>())
b.foo3(In())
compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.fir.kt
Vendored
+3 -3
View File
@@ -6,8 +6,8 @@ class A<T> {
}
fun test(a: A<out CharSequence>, y: Array<out CharSequence>) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "", "")
a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y)
a.foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
a.foo(*<!ARGUMENT_TYPE_MISMATCH!>y<!>)
// TODO: TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS probably redundant
a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y, "")
a.foo(*<!ARGUMENT_TYPE_MISMATCH!>y<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
}