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/Projections.fir.kt
Vendored
+5 -5
View File
@@ -37,16 +37,16 @@ fun testInOut() {
Inv<Int>().f(1)
(null as Inv<in Int>).f(1)
(null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
(null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
(null as Inv<out Int>).f(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
(null as Inv<*>).f(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
Inv<Int>().inf(1)
(null as Inv<in Int>).inf(1)
(null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
(null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
(null as Inv<out Int>).inf(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
(null as Inv<*>).inf(<!ARGUMENT_TYPE_MISMATCH!>1<!>) // !!
Inv<Int>().outf()
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>((null as Inv<in Int>).outf()) // Type mismatch
checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>(null as Inv<in Int>).outf()<!>) // Type mismatch
(null as Inv<out Int>).outf()
(null as Inv<*>).outf()
compiler/testData/diagnostics/tests/generics/capturedParameters/captured.fir.kt
Vendored
+4 -4
View File
@@ -10,11 +10,11 @@ class X {
fun testStar(y: X.Y<*>, t: Any) {
X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
}
fun testOut(y: X.Y<out Any>, t: Any) {
X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
}
fun testIn(y: X.Y<in Any>, t: Any) {
@@ -22,9 +22,9 @@ fun testIn(y: X.Y<in Any>, t: Any) {
}
fun <T : Any> testWithParameter(y: X.Y<T>, t: Any) {
X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
}
fun <T : Any> testWithCapturedParameter(y: X.Y<out T>, t: Any) {
X().<!INAPPLICABLE_CANDIDATE!>foo<!>(y, t)
X().foo(y, <!ARGUMENT_TYPE_MISMATCH!>t<!>)
}
compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
Vendored
+1 -1
View File
@@ -33,4 +33,4 @@ fun <T: Foo<<!UNRESOLVED_REFERENCE!>String.Bar<!>>> x() {}
fun Foo<String>.Bar.ext() {}
fun ex1(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!>): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!> {
}
}
compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.fir.kt
Vendored
+2 -2
View File
@@ -31,8 +31,8 @@ fun main() {
checkSubtype<Outer<*>.Inner<*>>(outer.bar())
checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.bar())
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.Inner())
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>outer.bar()<!>)
checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!ARGUMENT_TYPE_MISMATCH!>outer.Inner()<!>)
outer.set(outer.bar())
outer.set(outer.Inner())
compiler/testData/diagnostics/tests/generics/innerClasses/simple.fir.kt
Vendored
+2 -2
View File
@@ -25,8 +25,8 @@ fun main() {
checkSubtype<Outer<*>.Inner>(outer.bar())
checkSubtype<Outer<*>.Inner>(outer.Inner())
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner>(outer.bar())
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner>(outer.Inner())
checkSubtype<Outer<CharSequence>.Inner>(<!ARGUMENT_TYPE_MISMATCH!>outer.bar()<!>)
checkSubtype<Outer<CharSequence>.Inner>(<!ARGUMENT_TYPE_MISMATCH!>outer.Inner()<!>)
outer.set(outer.bar())
outer.set(outer.Inner())
compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.fir.kt
Vendored
+1 -1
View File
@@ -32,7 +32,7 @@ fun main() {
outer.set(outer.Inner())
val x: Outer<String>.Inner = factoryString()
outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
outer.set(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
val y: Outer<CharSequence>.Inner = infer<CharSequence>("")
outer.set(y)
compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.fir.kt
Vendored
+3 -3
View File
@@ -29,9 +29,9 @@ fun main() {
checkSubtype<Outer<out CharSequence>.Inner>(outer.bar())
checkSubtype<Outer<out CharSequence>.Inner>(outer.Inner())
outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.Inner())
outer.set(<!ARGUMENT_TYPE_MISMATCH!>outer.bar()<!>)
outer.set(<!ARGUMENT_TYPE_MISMATCH!>outer.Inner()<!>)
val x: Outer<String>.Inner = factoryString()
outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
outer.set(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.fir.kt
Vendored
+3 -3
View File
@@ -18,8 +18,8 @@ class Outer<E> {
bar(outerE(), baz())
bar(instance().outerE(), baz())
<!INAPPLICABLE_CANDIDATE!>bar<!>(topLevel().Inner<E>().baz(), topLevel().Inner<E>().baz())
<!INAPPLICABLE_CANDIDATE!>bar<!>(topLevel().Inner<E>().foo(), topLevel().Inner<E>().baz())
bar(topLevel().Inner<E>().baz(), <!ARGUMENT_TYPE_MISMATCH!>topLevel().Inner<E>().baz()<!>)
bar(<!ARGUMENT_TYPE_MISMATCH!>topLevel().Inner<E>().foo()<!>, <!ARGUMENT_TYPE_MISMATCH!>topLevel().Inner<E>().baz()<!>)
setE(foo())
}
@@ -45,5 +45,5 @@ fun foo() {
strInt.instance().Inner<Double>().checkType { _<Outer<String>.Inner<Double>>() }
Outer<String>().setInner(strInt)
Outer<CharSequence>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
Outer<CharSequence>().setInner(<!ARGUMENT_TYPE_MISMATCH!>strInt<!>)
}
compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.fir.kt
Vendored
+4 -4
View File
@@ -7,11 +7,11 @@ fun <E : CharSequence> foo1(x: E) {}
fun <E : CharSequence> E.foo2() {}
fun <F : String?> bar(x: F) {
<!INAPPLICABLE_CANDIDATE!>A<!>(x)
<!INAPPLICABLE_CANDIDATE!>A<!><F>(x)
A(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
A<F>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
<!INAPPLICABLE_CANDIDATE!>foo1<!>(x)
<!INAPPLICABLE_CANDIDATE!>foo1<!><F>(x)
foo1(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
foo1<F>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
x.<!INAPPLICABLE_CANDIDATE!>foo2<!>()
x.<!INAPPLICABLE_CANDIDATE!>foo2<!><F>()
compiler/testData/diagnostics/tests/generics/nullability/functionalBound.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ fun <E : String?, T : ((CharSequence) -> Unit)?> foo(x: E, y: T) {
}
if (y != null) {
<!INAPPLICABLE_CANDIDATE!>y<!>(x)
y(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
if (x != null && y != null) {
compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt
Vendored
+2 -2
View File
@@ -6,7 +6,7 @@ fun <T> foo(): T {
val x1: T = null
val x2: T? = null
<!INAPPLICABLE_CANDIDATE!>bar<!><T>(null)
bar<T>(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
bar<T?>(null)
return null
@@ -23,7 +23,7 @@ class A<F> {
val x1: F = null
val x2: F? = null
<!INAPPLICABLE_CANDIDATE!>xyz<!>(null)
xyz(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
bar<F?>(null)
return null
compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt
Vendored
+4 -4
View File
@@ -17,7 +17,7 @@ fun <T : CharSequence?> foo(x: T) {
bar1(x)
bar1<CharSequence>(x)
bar2(x)
<!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
if (x is String) {
@@ -35,7 +35,7 @@ fun <T : CharSequence?> foo(x: T) {
bar1(x)
bar2(x)
<!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
if (1 == 1) {
@@ -43,10 +43,10 @@ fun <T : CharSequence?> foo(x: T) {
bar1(x)
bar1<CharSequence>(x)
bar2(x)
<!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
bar1(y)
bar2(y)
<!INAPPLICABLE_CANDIDATE!>bar3<!>(y)
bar3(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
}
}
compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt
Vendored
+7 -7
View File
@@ -17,15 +17,15 @@ class A<F> {
val x2 = foo2(x)
x2.checkType { _<F>() }
<!INAPPLICABLE_CANDIDATE!>foo1<!><F?>(y)
<!INAPPLICABLE_CANDIDATE!>foo1<!>(y)
foo1<F?>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
foo1(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
foo2<F?>(y)
val x3 = foo2(y)
x3.checkType { _<F?>() }
<!INAPPLICABLE_CANDIDATE!>foo1<!><F>(y)
<!INAPPLICABLE_CANDIDATE!>foo2<!><F>(y)
foo1<F>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
foo2<F>(<!ARGUMENT_TYPE_MISMATCH!>y<!>)
foo1<Z>(z)
@@ -37,13 +37,13 @@ class A<F> {
val x5 = foo2(z)
x4.checkType { _<Z>() }
<!INAPPLICABLE_CANDIDATE!>foo1<!><W>(w)
<!INAPPLICABLE_CANDIDATE!>foo1<!>(w)
foo1<W>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
foo1(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
foo2<W>(w)
val x6 = foo2(w)
x6.checkType { _<W>() }
<!INAPPLICABLE_CANDIDATE!>foo1<!><W>(w)
foo1<W>(<!ARGUMENT_TYPE_MISMATCH!>w<!>)
}
}
compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.fir.kt
Vendored
+20 -20
View File
@@ -18,9 +18,9 @@ class A<F> {
fun <Z : F, W : Z?> bar() {
// F
fooInv1<Inv<F>>(Inv<F>())
<!INAPPLICABLE_CANDIDATE!>fooInv2<!><Inv<F>>(Inv<F>())
fooInv2<Inv<F>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)
fooInv1(Inv<F>())
<!INAPPLICABLE_CANDIDATE!>fooInv2<!>(Inv<F>())
fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<F>()<!>)
fooIn1<In<F?>>(In<F?>())
fooIn2<In<F?>>(In<F?>())
@@ -33,15 +33,15 @@ class A<F> {
fooOut2(Out<F>())
// Z
<!INAPPLICABLE_CANDIDATE!>fooInv1<!><Inv<Z>>(Inv<Z>())
<!INAPPLICABLE_CANDIDATE!>fooInv2<!><Inv<Z>>(Inv<Z>())
<!INAPPLICABLE_CANDIDATE!>fooInv1<!>(Inv<Z>())
<!INAPPLICABLE_CANDIDATE!>fooInv2<!>(Inv<Z>())
fooInv1<Inv<Z>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
fooInv2<Inv<Z>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
fooInv1(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<Z>()<!>)
<!INAPPLICABLE_CANDIDATE!>fooIn1<!><In<Z?>>(In<Z?>())
<!INAPPLICABLE_CANDIDATE!>fooIn2<!><In<Z?>>(In<Z?>())
<!INAPPLICABLE_CANDIDATE!>fooIn1<!>(In<Z?>())
<!INAPPLICABLE_CANDIDATE!>fooIn2<!>(In<Z?>())
fooIn1<In<Z?>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
fooIn2<In<Z?>>(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
fooIn1(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
fooIn2(<!ARGUMENT_TYPE_MISMATCH!>In<Z?>()<!>)
fooOut1<Out<Z>>(Out<Z>())
fooOut2<Out<Z>>(Out<Z>())
@@ -49,19 +49,19 @@ class A<F> {
fooOut2(Out<Z>())
// W
<!INAPPLICABLE_CANDIDATE!>fooInv1<!><Inv<W>>(Inv<W>())
<!INAPPLICABLE_CANDIDATE!>fooInv2<!><Inv<W>>(Inv<W>())
<!INAPPLICABLE_CANDIDATE!>fooInv1<!>(Inv<W>())
<!INAPPLICABLE_CANDIDATE!>fooInv2<!>(Inv<W>())
fooInv1<Inv<W>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
fooInv2<Inv<W>>(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
fooInv1(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
fooInv2(<!ARGUMENT_TYPE_MISMATCH!>Inv<W>()<!>)
<!INAPPLICABLE_CANDIDATE!>fooIn1<!><In<W?>>(In<W?>())
<!INAPPLICABLE_CANDIDATE!>fooIn2<!><In<W?>>(In<W?>())
<!INAPPLICABLE_CANDIDATE!>fooIn1<!>(In<W?>())
<!INAPPLICABLE_CANDIDATE!>fooIn2<!>(In<W?>())
fooIn1<In<W?>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
fooIn2<In<W?>>(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
fooIn1(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
fooIn2(<!ARGUMENT_TYPE_MISMATCH!>In<W?>()<!>)
<!INAPPLICABLE_CANDIDATE!>fooOut1<!><Out<W>>(Out<W>())
fooOut1<Out<W>>(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
fooOut2<Out<W>>(Out<W>())
<!INAPPLICABLE_CANDIDATE!>fooOut1<!>(Out<W>())
fooOut1(<!ARGUMENT_TYPE_MISMATCH!>Out<W>()<!>)
fooOut2(Out<W>())
}
}
compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt
Vendored
+2 -2
View File
@@ -13,6 +13,6 @@ fun <T : String?> foo(x: T) {
bar1(x)
bar2(x)
<!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
<!INAPPLICABLE_CANDIDATE!>bar4<!>(x)
bar3(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
bar4(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
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!>""<!>)
}
compiler/testData/diagnostics/tests/generics/starProjections/invalid.fir.kt
Vendored
+1 -1
View File
@@ -17,7 +17,7 @@ fun main(a: A<*>, j: JavaClass<*>, i2: Inv2<*>) {
j.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
i2.x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
j.<!INAPPLICABLE_CANDIDATE!>bar<!>(1, 2, Any())
j.bar(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>, <!ARGUMENT_TYPE_MISMATCH!>Any()<!>)
j.bar(null)
}
compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt
Vendored
+2 -2
View File
@@ -10,8 +10,8 @@ class A<out T, in E> {
fun foo(x: A<String, Any?>, cs: CharSequence, ls: List<CharSequence>) {
val y: A<CharSequence, String> = x
y.<!INAPPLICABLE_CANDIDATE!>foo<!>(cs)
val s: String = y.<!INAPPLICABLE_CANDIDATE!>foo<!>(cs, ls)
y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>)
val s: String = y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)
val ls2: List<String> = y.bar()
}
compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt
Vendored
+1 -1
View File
@@ -9,6 +9,6 @@ public class JavaClass {
// FILE: main.kt
fun foo() {
JavaClass().foo(Any())
JavaClass().<!INAPPLICABLE_CANDIDATE!>bar<!>(Any())
JavaClass().bar(<!ARGUMENT_TYPE_MISMATCH!>Any()<!>)
JavaClass().bar("")
}