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/fir/analysis-tests/testData/resolve/arguments/argParamTypeMismatch.fir.txt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ FILE: argParamTypeMismatch.kt
lval int: R|kotlin/Int| = Int(1)
<Inapplicable(INAPPLICABLE): /foo>#(R|<local>/int|)
<Inapplicable(INAPPLICABLE): /foo>#(Int(2))
<Inapplicable(INAPPLICABLE): /foo>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <kind=EXACTLY_ONCE> {
<Inapplicable(INAPPLICABLE): /foo>#(R|kotlin/run|<R|kotlin/Int|>(<L> = run@fun <anonymous>(): R|kotlin/Int| <inline=Inline, kind=EXACTLY_ONCE> {
^ Int(20)
}
))
compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ public @interface Ann {
// FILE: main.kt
@Ann(x = 10, s = "")
<!INAPPLICABLE_CANDIDATE!>@Ann(10, "")<!>
@Ann(<!ARGUMENT_TYPE_MISMATCH!>10<!>, <!ARGUMENT_TYPE_MISMATCH!>""<!>)
@Ann(x = 10, s = "", y = 10)
class A
compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
Vendored
+1 -1
View File
@@ -21,6 +21,6 @@ fun test() {
baz(1, "my", "yours")
baz(1, z = true)
<!INAPPLICABLE_CANDIDATE!>baz<!>(0, "", false)
baz(0, "", <!ARGUMENT_TYPE_MISMATCH!>false<!>)
}
compiler/fir/analysis-tests/testData/resolve/arguments/destructuring.kt
Vendored
+2 -2
View File
@@ -6,8 +6,8 @@ fun foo2(block: (C, C) -> Unit) = block(C(0, ""), C(0, ""))
fun test() {
foo1 { (x, y) -> C(x, y) }
foo1 { (x: Int, y: String) -> C(x, y) }
foo1 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x, y) }
foo1 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x<!>, <!ARGUMENT_TYPE_MISMATCH!>y<!>) }
foo2 { (x, y), (z, w) -> C(x + z, y + w) }
foo2 { (x: Int, y: String), (z: Int, w: String) -> C(x + z, y + w) }
foo2 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>), (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>z: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>w: Int<!>) -> <!INAPPLICABLE_CANDIDATE!>C<!>(x + z, y + w) }
foo2 { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>x: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>y: Int<!>), (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>z: String<!>, <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>w: Int<!>) -> C(<!ARGUMENT_TYPE_MISMATCH!>x + z<!>, <!ARGUMENT_TYPE_MISMATCH!>y + w<!>) }
}
compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt
Vendored
+5 -5
View File
@@ -17,9 +17,9 @@ fun test_1() {
}
fun test_2() {
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(10000000000)
takeInt(<!ARGUMENT_TYPE_MISMATCH!>10000000000<!>)
takeLong(10000000000)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000<!>)
}
fun test_3() {
@@ -35,14 +35,14 @@ fun test_4() {
}
fun test_5() {
<!INAPPLICABLE_CANDIDATE!>takeString<!>(1)
<!INAPPLICABLE_CANDIDATE!>takeString<!>(run { 1 })
takeString(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
takeString(<!ARGUMENT_TYPE_MISMATCH!>run { 1 }<!>)
}
annotation class Ann(val x: Byte)
@Ann(10)
fun test_6() {
<!INAPPLICABLE_CANDIDATE!>@Ann(300)<!>
@Ann(<!ARGUMENT_TYPE_MISMATCH!>300<!>)
val x = ""
}
compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ public @interface Ann {
@Ann("a", "b")
fun test_1() {}
<!INAPPLICABLE_CANDIDATE!>@Ann(arrayOf("a", "b"))<!>
@Ann(<!ARGUMENT_TYPE_MISMATCH!>arrayOf("a", "b")<!>)
fun test_2() {}
@Ann(*arrayOf("a", "b"))
compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt
Vendored
+1 -1
View File
@@ -13,6 +13,6 @@ fun takeOutA(array: Array<out A>) {}
fun test(array: Array<B>) {
A.take(array)
<!INAPPLICABLE_CANDIDATE!>takeA<!>(array)
takeA(<!ARGUMENT_TYPE_MISMATCH!>array<!>)
takeOutA(array)
}
compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt
Vendored
+18 -18
View File
@@ -31,33 +31,33 @@ fun test_3() {
fun takeByte(b: Byte) {}
fun test_4() {
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 1)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + 127)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 - 1)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(-100 - 100)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(10 * 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 * 100)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + 127<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 - 1<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>-100 - 100<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>10 * 10<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 * 100<!>)
<!UNRESOLVED_REFERENCE!>taleByte<!>(10 / 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 % 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 % 10)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 and 100)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(128 and 511)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(100 or 100)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1000 or 0)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(511 xor 511)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(512 xor 511)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 % 10<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 % 10<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 and 100<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>128 and 511<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>100 or 100<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1000 or 0<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>511 xor 511<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>512 xor 511<!>)
}
fun test_5() {
takeByte(-1)
takeByte(+1)
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1.inv())
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1.inv()<!>)
}
fun test_6() {
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 127 + 1 })
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(1 + run { 1 })
<!INAPPLICABLE_CANDIDATE!>takeByte<!>(run { 1 + 1 })
takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 127 + 1 }<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>1 + run { 1 }<!>)
takeByte(<!ARGUMENT_TYPE_MISMATCH!>run { 1 + 1 }<!>)
1 + 1
run { 1 }
1 + run { 1 }
compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
Vendored
+2 -2
View File
@@ -8,10 +8,10 @@ fun test() {
foo(third = false, second = 2.71, fourth = "?!", first = 0)
foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
foo(<!ARGUMENT_TYPE_MISMATCH!>0.0<!>, <!ARGUMENT_TYPE_MISMATCH!>false<!>, <!ARGUMENT_TYPE_MISMATCH!>0<!>, "")
foo(1, 2.0, third = true, "")
foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
foo(first = <!ARGUMENT_TYPE_MISMATCH!>0.0<!>, second = <!ARGUMENT_TYPE_MISMATCH!>0<!>, third = <!ARGUMENT_TYPE_MISMATCH!>""<!>, fourth = <!ARGUMENT_TYPE_MISMATCH!>false<!>)
foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
foo(0, 0.0, false, <!NAMED_PARAMETER_NOT_FOUND!>foth<!> = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
Vendored
+2 -2
View File
@@ -7,8 +7,8 @@ fun test() {
foo(1, "my", "yours")
foo(1, *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE!>foo<!>("")
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, 2)
foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
foo(1, <!ARGUMENT_TYPE_MISMATCH!>2<!>)
bar(1, z = true, y = *arrayOf("my", "yours"))
compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ fun bar(x: B) {}
fun test(c: C) {
// Argument mapping error
<!INAPPLICABLE_CANDIDATE!>foo<!>("")
foo(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
// Ambiguity
<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>(c)
compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt
Vendored
+1 -1
View File
@@ -72,7 +72,7 @@ fun test_4(x: Any, y: Any) {
}
)
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x) // Bad
takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>) // Bad
takeInt(y) // OK
takeInt(a) // Bad
}
compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ class B3_3 : A3("", true)
class B3_4 : <!NONE_APPLICABLE!>A3<!>("", Unit)
open class A4(val x: Byte)
class B4 : <!INAPPLICABLE_CANDIDATE!>A4<!>( 1 + 1)
class B4 : A4( <!ARGUMENT_TYPE_MISMATCH!>1 + 1<!>)
open class A5 {
constructor(x: Byte)
compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt
Vendored
+2 -2
View File
@@ -25,7 +25,7 @@ class E<T> {
// selection of the proper constructor
// but a type mismatch for the first
// argument
constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10) {}
constructor(e: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 10) {}
}
class I<T> {
@@ -33,7 +33,7 @@ class I<T> {
// selection of the proper constructor
// but a type mismatch for the first
// argument
constructor(e: T, i: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>(i, 10)
constructor(e: T, i: Int) : this(<!ARGUMENT_TYPE_MISMATCH!>i<!>, 10)
}
class J<T> {
compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt
Vendored
+2 -2
View File
@@ -7,9 +7,9 @@ class A {
class B(other: B = <!NO_THIS!>this<!>)
class C() {
constructor(x: Int) : <!INAPPLICABLE_CANDIDATE!>this<!>({
constructor(x: Int) : this({
val a = 10
<!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
<!ARGUMENT_TYPE_MISMATCH, INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>
}) {}
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/multipleBounds.kt
Vendored
+2 -2
View File
@@ -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
compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt
Vendored
+1 -1
View File
@@ -26,7 +26,7 @@ class G<E : <!FINAL_UPPER_BOUND!>Double<!>>(val balue: E) : F<E>(balue) {
override var rest: E = balue
}
class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : F<E>(<!ARGUMENT_TYPE_MISMATCH!>balue<!>) {
override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
Vendored
+1 -1
View File
@@ -27,7 +27,7 @@ class G<E : <!FINAL_UPPER_BOUND!>Double<!>>(val balue: E) : F<E>(balue) {
override fun rest(): E = balue
}
class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : <!INAPPLICABLE_CANDIDATE!>F<E><!>(balue) {
class H<E : <!FINAL_UPPER_BOUND!>String<!>>(val balue: E) : F<E>(<!ARGUMENT_TYPE_MISMATCH!>balue<!>) {
override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.fir.txt
Vendored
+5 -5
View File
@@ -22,7 +22,7 @@ FILE: upperBoundViolated.kt
lval b1: R|B<kotlin/Int>| = R|/B.B|<R|kotlin/Int|>()
lval b2: R|B<C>| = R|/B.B|<R|C|>()
lval b3: R|B<kotlin/Any?>| = R|/B.B|<R|kotlin/Any?|>()
lval b4: R|B<A>| = R|/B.B|<<ERROR TYPE REF: Symbol not found for UnexistingType>>()
lval b4: R|ERROR CLASS: Unresolved name: NumberPhile| = R|/B.B|<<ERROR TYPE REF: Symbol not found for UnexistingType>>().<Unresolved name: NL>#(ERROR_EXPR(No right operand)).<Unresolved name: Int>#(<Call has no callee>#()).<Unresolved name: NumberPhile>#(ERROR_EXPR(No right operand))
lval b5: R|B<B<ERROR CLASS: Symbol not found for UnexistingType>>| = R|/B.B|<R|B<ERROR CLASS: Symbol not found for UnexistingType>|>()
R|/fest|<R|kotlin/Boolean|>()
R|/fest|<R|C|>()
@@ -58,8 +58,8 @@ FILE: upperBoundViolated.kt
}
public final typealias NL<K> = R|NumColl<kotlin/collections/List<K>>|
public final val test7: R|NumColl<kotlin/collections/List<kotlin/Int>>| = R|/NumColl.NumColl|<R|kotlin/Int|>()
public get(): R|NumColl<kotlin/collections/List<kotlin/Int>>|
public final val test7: R|ERROR CLASS: Unresolved name: NumberPhile| = R|/NumColl.NumColl|<R|kotlin/Int|>().<Unresolved name: NumberPhile>#(ERROR_EXPR(No right operand))
public get(): R|ERROR CLASS: Unresolved name: NumberPhile|
public final val test8: R|NumColl<kotlin/collections/List<kotlin/String>>| = R|/NumColl.NumColl|<R|kotlin/String|>()
public get(): R|NumColl<kotlin/collections/List<kotlin/String>>|
public final class NumberPhile<T : R|kotlin/Number|> : R|kotlin/Any| {
@@ -70,5 +70,5 @@ FILE: upperBoundViolated.kt
}
public final val np1: R|NumberPhile<kotlin/Int>| = R|/NumberPhile.NumberPhile|<R|kotlin/Int|>(Int(10))
public get(): R|NumberPhile<kotlin/Int>|
public final val np2: R|NumberPhile<kotlin/String>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|kotlin/String|>(String(Test))
public get(): R|NumberPhile<kotlin/String>|
public final val np2: R|NumberPhile<kotlin/Number>| = <Inapplicable(INAPPLICABLE): /NumberPhile.NumberPhile>#<R|kotlin/Number|>(String(Test))
public get(): R|NumberPhile<kotlin/Number>|
compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt
Vendored
+3 -3
View File
@@ -14,7 +14,7 @@ fun test() {
val b1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
val b2 = B<C>()
val b3 = B<<!UPPER_BOUND_VIOLATED!>Any?<!>>()
val b4 = B<<!UNRESOLVED_REFERENCE!>UnexistingType<!>>()
val b4 = B<<!UNRESOLVED_REFERENCE!>UnexistingType<!>>()<!UNRESOLVED_REFERENCE{PSI}!>NL<!><!SYNTAX{PSI}!><<!>Int<!SYNTAX{PSI}!>><!>()NumberPhile<!SYNTAX{PSI}!><!>
val b5 = B<<!UPPER_BOUND_VIOLATED!>B<<!UNRESOLVED_REFERENCE!>UnexistingType<!>><!>>()
fest<<!UPPER_BOUND_VIOLATED!>Boolean<!>>()
fest<C>()
@@ -40,9 +40,9 @@ fun <K, L : K> rest() {
class NumColl<T : Collection<Number>>
typealias NL<K> = NumColl<List<K>>
val test7 = NL<Int>()
val test7 = NL<Int>()<!UNRESOLVED_REFERENCE{PSI}!>NumberPhile<!><!SYNTAX{PSI}!><!>
val test8 = NL<String>()
class NumberPhile<T: Number>(x: T)
val np1 = NumberPhile(10)
val np2 = <!INAPPLICABLE_CANDIDATE!>NumberPhile<!>("Test")
val np2 = NumberPhile(<!ARGUMENT_TYPE_MISMATCH!>"Test"<!>)
compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ fun test() {
useEnum(TestEnum.THIRD)
useVararg(TestEnum.FIRST, TestEnum.SECOND)
<!INAPPLICABLE_CANDIDATE!>useVararg<!>(1, 2, 3, 4, 5)
useVararg(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>, <!ARGUMENT_TYPE_MISMATCH!>3<!>, <!ARGUMENT_TYPE_MISMATCH!>4<!>, <!ARGUMENT_TYPE_MISMATCH!>5<!>)
}
compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.fir.txt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ FILE: typeParameters.kt
}
public final fun main(fooImpl: R|FooImpl|, bar: R|Bar|): R|kotlin/Unit| {
lval a: R|FooImpl| = R|/foo|<R|FooImpl|>(R|<local>/fooImpl|)
lval b: R|Bar| = <Inapplicable(INAPPLICABLE): /foo>#<R|Bar|>(R|<local>/bar|)
lval b: R|Foo| = <Inapplicable(INAPPLICABLE): /foo>#<R|Foo|>(R|<local>/bar|)
}
compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt
Vendored
+1 -1
View File
@@ -7,5 +7,5 @@ fun <T : Foo> foo(t: T) = t
fun main(fooImpl: FooImpl, bar: Bar) {
val a = foo(fooImpl)
val b = <!INAPPLICABLE_CANDIDATE!>foo<!>(bar)
val b = foo(<!ARGUMENT_TYPE_MISMATCH!>bar<!>)
}
compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt
Vendored
+1 -1
View File
@@ -6,6 +6,6 @@ fun <T : Foo> foo(t: T) = t
fun main(fooImpl: FooImpl, fooBarImpl: FooBarImpl) {
val a = <!INAPPLICABLE_CANDIDATE!>foo<!><FooImpl>(fooBarImpl)
val a = foo<FooImpl>(<!ARGUMENT_TYPE_MISMATCH!>fooBarImpl<!>)
val b = foo<Foo>(fooImpl)
}
compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.fir.txt
Vendored
+2 -2
View File
@@ -11,7 +11,7 @@ FILE: nullableIntegerLiteralType.kt
}
}
<Inapplicable(MAY_THROW_RUNTIME_ERROR): /takeInt>#(R|<local>/x|)
<Inapplicable(INAPPLICABLE): /takeInt>#(R|<local>/x|)
}
public final fun test_2(b: R|kotlin/Boolean|, y: R|kotlin/Int|): R|kotlin/Unit| {
lval x: R|kotlin/Int?| = when () {
@@ -23,5 +23,5 @@ FILE: nullableIntegerLiteralType.kt
}
}
<Inapplicable(MAY_THROW_RUNTIME_ERROR): /takeInt>#(R|<local>/x|)
<Inapplicable(INAPPLICABLE): /takeInt>#(R|<local>/x|)
}
compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ fun takeInt(x: Int) {}
fun test_1(b: Boolean) {
val x = if (b) 1 else null
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
fun test_2(b: Boolean, y: Int) {
val x = if (b) y else null
<!INAPPLICABLE_CANDIDATE!>takeInt<!>(x)
takeInt(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt
Vendored
+1 -1
View File
@@ -24,7 +24,7 @@ fun test_1_3(resolvedCall: ResolvedCall<CallableDescriptor>) {
}
fun test_2_1(resolvedCall: ResolvedCall<out CallableDescriptor>, d: CallableDescriptor) {
val x = resolvedCall.<!INAPPLICABLE_CANDIDATE!>updateD<!>(d) // should fail
val x = resolvedCall.updateD(<!ARGUMENT_TYPE_MISMATCH!>d<!>) // should fail
}
fun test_2_2(resolvedCall: ResolvedCall<in CallableDescriptor>, d: CallableDescriptor) {
compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt
Vendored
+3 -3
View File
@@ -12,10 +12,10 @@ val rr = Outer<String>().Inner<Int>()
val rrq = Boxed<String>().substitute()
fun check() {
<!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<Int>().Inner<Int>()) // illegal
<!INAPPLICABLE_CANDIDATE!>accept<!>(Outer<String>().Inner<String>()) // illegal
accept(<!ARGUMENT_TYPE_MISMATCH!>Outer<Int>().Inner<Int>()<!>) // illegal
accept(<!ARGUMENT_TYPE_MISMATCH!>Outer<String>().Inner<String>()<!>) // illegal
accept(Outer<String>().Inner<Int>()) // ok
<!INAPPLICABLE_CANDIDATE!>accept<!>(Boxed<Int>().substitute()) // illegal
accept(<!ARGUMENT_TYPE_MISMATCH!>Boxed<Int>().substitute()<!>) // illegal
accept(Boxed<String>().substitute()) // ok
}
compiler/fir/analysis-tests/testData/resolve/kt41984.fir.txt
Vendored
+1 -1
View File
@@ -21,6 +21,6 @@ FILE: main.kt
}
public final fun test_1(b: R|B<kotlin/Int>|, x: R|kotlin/Int|, inv: R|Inv<kotlin/Int>|): R|kotlin/Unit| {
R|<local>/b|.R|SubstitutionOverride</B.take: R|kotlin/String|>|(R|<local>/x|)
R|<local>/b|.<Inapplicable(MAY_THROW_RUNTIME_ERROR): /B.take>#(Null(null))
R|<local>/b|.<Inapplicable(INAPPLICABLE): /B.take>#(Null(null))
R|<local>/b|.R|SubstitutionOverride</B.takeInv: R|kotlin/String|>|(R|<local>/inv|)
}
compiler/fir/analysis-tests/testData/resolve/kt41984.kt
Vendored
+1 -1
View File
@@ -26,6 +26,6 @@ open class B<V> : A<Any, V>() {
fun test_1(b: B<Int>, x: Int, inv: Inv<Int>) {
b.take(x)
b.<!INAPPLICABLE_CANDIDATE!>take<!>(null)
b.take(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
b.takeInv(inv)
}
compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.fir.txt
Vendored
+1 -1
View File
@@ -24,5 +24,5 @@ FILE: supertypeGenericsComplex.kt
}
public final fun f(list: R|kotlin/collections/MutableList<X>|, s: R|kotlin/collections/MutableList<kotlin/CharSequence>|): R|kotlin/Unit| {
R|/C.C|().R|SubstitutionOverride</C.f: R|kotlin/Unit|>|<R|X|>(R|<local>/list|, R|<local>/s|)
R|/C.C|().<Inapplicable(INAPPLICABLE): /C.f>#<R|kotlin/CharSequence|>(R|<local>/s|, R|<local>/list|)
R|/C.C|().<Inapplicable(INAPPLICABLE): /C.f>#<R|Out<kotlin/CharSequence>|>(R|<local>/s|, R|<local>/list|)
}
compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt
Vendored
+1 -1
View File
@@ -10,5 +10,5 @@ class C : Base<CharSequence>()
fun f(list: MutableList<X>, s: MutableList<CharSequence>) {
C().f(list, s)
C().<!INAPPLICABLE_CANDIDATE!>f<!>(s, list)
C().f(<!ARGUMENT_TYPE_MISMATCH!>s<!>, <!ARGUMENT_TYPE_MISMATCH!>list<!>)
}
compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt
Vendored
+1 -1
View File
@@ -11,5 +11,5 @@ public interface SLRUMap<V> {
// FILE: main.kt
fun <V> SLRUMap<V>.getOrPut(value: V) {
<!INAPPLICABLE_CANDIDATE!>takeV<!>(value)
takeV(<!ARGUMENT_TYPE_MISMATCH!>value<!>)
}
compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.fir.txt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ FILE: main.kt
^ R|<local>/x|.R|kotlin/Number.toInt|().R|kotlin/Any.toString|()
}
))
<Inapplicable(INAPPLICABLE): /foo2>#(R|/MyFunction|<R|kotlin/Number|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>| <inline=NoInline> {
<Inapplicable(INAPPLICABLE): /foo2>#(R|/MyFunction|<R|ft<kotlin/Int, kotlin/Int?>|, R|ft<kotlin/String, kotlin/String?>|>(<L> = MyFunction@fun <anonymous>(x: R|kotlin/Int|): R|ft<kotlin/String, kotlin/String?>| <inline=NoInline> {
^ R|<local>/x|.R|kotlin/Any.toString|()
}
))
compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt
Vendored
+2 -2
View File
@@ -18,9 +18,9 @@ fun main() {
x.toInt().toString()
})
<!INAPPLICABLE_CANDIDATE!>foo2<!>(MyFunction { x: Int ->
foo2(<!ARGUMENT_TYPE_MISMATCH!>MyFunction { x: Int ->
x.toString()
})
}<!>)
foo3(
MyFunction { x ->
compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt
Vendored
+4 -4
View File
@@ -10,13 +10,13 @@ fun foo(m: MyRunnable) {}
fun MyRunnable(x: (Int) -> Boolean) = 1
fun main() {
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable { x ->
foo(<!ARGUMENT_TYPE_MISMATCH!>MyRunnable { x ->
x > 1
})
}<!>)
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable({ it > 1 }))
foo(<!ARGUMENT_TYPE_MISMATCH!>MyRunnable({ it > 1 })<!>)
val x = { x: Int -> x > 1 }
<!INAPPLICABLE_CANDIDATE!>foo<!>(MyRunnable(x))
foo(<!ARGUMENT_TYPE_MISMATCH!>MyRunnable(x)<!>)
}
compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
Vendored
+2 -2
View File
@@ -21,8 +21,8 @@ fun main() {
x.toInt().toString()
}
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo2<!> { x: Int ->
x.toString()
JavaUsage.foo2 { x: Int ->
<!ARGUMENT_TYPE_MISMATCH!>x.toString()<!>
}
JavaUsage.foo3(
compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
Vendored
+4 -4
View File
@@ -29,11 +29,11 @@ fun main() {
foo1 { x -> x > 1 }
foo1(f)
<!INAPPLICABLE_CANDIDATE!>foo2<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
<!INAPPLICABLE_CANDIDATE!>foo2<!>(f)
foo2 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
foo2(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
<!INAPPLICABLE_CANDIDATE!>foo3<!> { x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }
<!INAPPLICABLE_CANDIDATE!>foo3<!>(f)
foo3 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
foo3(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
foo4 { x -> x > 1 }
foo4(f)
compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
Vendored
+4 -4
View File
@@ -18,14 +18,14 @@ public class JavaUsage {
fun foo(m: MyRunnable) {}
fun main() {
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!> {
JavaUsage.foo {
x ->
x <!UNRESOLVED_REFERENCE!>><!> 1
<!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!>
}
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> > 1 })
JavaUsage.foo({ <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> > 1<!> })
val x = { x: Int -> x > 1 }
JavaUsage.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
JavaUsage.foo(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
}
compiler/fir/analysis-tests/testData/resolve/suppress/singleError.fir.txt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
FILE: singleError.kt
public final fun foo(x: R|kotlin/String|): R|kotlin/Unit| {
}
@R|kotlin/Suppress|(vararg(String(INAPPLICABLE_CANDIDATE))) public final fun bar(): R|kotlin/Unit| {
@R|kotlin/Suppress|(vararg(String(ARGUMENT_TYPE_MISMATCH))) public final fun bar(): R|kotlin/Unit| {
<Inapplicable(INAPPLICABLE): /foo>#(Int(10))
}
compiler/fir/analysis-tests/testData/resolve/suppress/singleError.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
fun foo(x: String) {}
@Suppress("INAPPLICABLE_CANDIDATE")
@Suppress("ARGUMENT_TYPE_MISMATCH")
fun bar() {
foo(10)
}
compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt
Vendored
+1 -1
View File
@@ -90,5 +90,5 @@ fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<o
inv1.take(a)
inv2.take(a)
inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
inv3.take(<!ARGUMENT_TYPE_MISMATCH!>a<!>)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KJKComplexHierarchyWithNested.kt
Vendored
+2 -2
View File
@@ -5,9 +5,9 @@ fun main(k: KSub, vString: SuperClass<String>.NestedInSuperClass, vInt: SuperCla
k.getImpl().nestedI(vString)
// TODO: Support parametrisized inner classes
k.getImpl().<!INAPPLICABLE_CANDIDATE!>nestedI<!>(vInt)
k.getImpl().nestedI(<!ARGUMENT_TYPE_MISMATCH!>vInt<!>)
k.getNestedSubClass().nested("")
k.getNestedSubClass().<!INAPPLICABLE_CANDIDATE!>nested<!>(1)
k.getNestedSubClass().nested(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
}
// FILE: J1.java
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameter.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ public class JavaClass {
// FILE: K2.kt
fun main() {
JavaClass.baz(KotlinClass())
JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/KotlinClassParameterGeneric.kt
Vendored
+2 -2
View File
@@ -10,6 +10,6 @@ public class JavaClass {
fun main() {
JavaClass.baz(KotlinClass())
JavaClass.baz(KotlinClass<Int>())
JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>(KotlinClass<String>())
JavaClass.<!INAPPLICABLE_CANDIDATE!>baz<!>("")
JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>KotlinClass<String>()<!>)
JavaClass.baz(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
}
compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out
Vendored
+3 -3
View File
@@ -10,9 +10,9 @@ compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:2:74: error: unresolv
compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:7:20: error: 'this' is not defined in this context
class B(other: B = this)
^
compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:10:27: error: inapplicable candidate(s): /C.C
constructor(x: Int) : this({
^
compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:12:9: error: argument type mismatch: actual type is ERROR CLASS: Cannot access ''<this>'' before superclass constructor has been called but TypeVariable(_L) was expected
this
^
compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:12:9: error: cannot access '<this>' before superclass constructor has been called
this
^
compiler/testData/diagnostics/tests/AutoCreatedIt.fir.kt
Vendored
+1 -1
View File
@@ -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) {}
compiler/testData/diagnostics/tests/Basic.fir.kt
Vendored
+2 -2
View File
@@ -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"
}
compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.fir.kt
Vendored
+1 -1
View File
@@ -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
compiler/testData/diagnostics/tests/Constants.fir.kt
Vendored
+9 -9
View File
@@ -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())
}
compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.fir.kt
Vendored
+2 -2
View File
@@ -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)
compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.fir.kt
Vendored
+1 -1
View File
@@ -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) {}
compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt
Vendored
+2 -2
View File
@@ -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!!
compiler/testData/diagnostics/tests/ExtensionCallInvoke.fir.kt
Vendored
+1 -1
View File
@@ -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()
}
compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
Vendored
+2 -2
View File
@@ -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()({})
compiler/testData/diagnostics/tests/MultipleBounds.fir.kt
Vendored
+2 -2
View File
@@ -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
compiler/testData/diagnostics/tests/ResolveToJava.fir.kt
Vendored
+1 -1
View File
@@ -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>
compiler/testData/diagnostics/tests/Serializable.fir.kt
Vendored
+2 -2
View File
@@ -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 {
compiler/testData/diagnostics/tests/Varargs.fir.kt
Vendored
+1 -1
View File
@@ -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!>{}<!>
compiler/testData/diagnostics/tests/Variance.fir.kt
Vendored
+2 -2
View File
@@ -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
}
compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt
Vendored
+3 -3
View File
@@ -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>
}
}
}
compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt
Vendored
+3 -3
View File
@@ -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
}
}
compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt
Vendored
+2 -2
View File
@@ -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
compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.fir.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
package test
<!INAPPLICABLE_CANDIDATE!>@BadAnnotation(1)<!>
@BadAnnotation(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
object SomeObject
val some = SomeObject
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.fir.kt
Vendored
+1 -1
View File
@@ -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
compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.fir.kt
Vendored
+1 -1
View File
@@ -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
compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.fir.kt
Vendored
+1 -1
View File
@@ -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<!>)
}
compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.fir.kt
Vendored
+1 -1
View File
@@ -13,7 +13,7 @@ fun foo() {
return@l1 103
}
bar <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> {
bar @Ann(<!ARGUMENT_TYPE_MISMATCH!>""<!>) {
104
}
}
compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.fir.kt
Vendored
+1 -1
View File
@@ -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() {}
}
compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.fir.kt
Vendored
+1 -1
View File
@@ -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")
compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ class C<T> {
}
fun test(a: C<out CharSequence>) {
<!INAPPLICABLE_CANDIDATE!>a[1]<!> = 25
a[1] = <!ARGUMENT_TYPE_MISMATCH!>25<!>
}
compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.fir.kt
Vendored
+1 -1
View File
@@ -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<!>
}
compiler/testData/diagnostics/tests/callableReference/bound/companionObject.fir.kt
Vendored
+2 -2
View File
@@ -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
compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.fir.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ fun cr() {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, ::<!UNRESOLVED_REFERENCE!>cr<!>)
<!INAPPLICABLE_CANDIDATE!>takeIt<!>(42, { })
takeIt(42, <!ARGUMENT_TYPE_MISMATCH!>{ }<!>)
}
compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt
Vendored
+1 -1
View File
@@ -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."<!>)
}
compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.fir.kt
Vendored
+4 -4
View File
@@ -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)
compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt
Vendored
+1 -1
View File
@@ -12,7 +12,7 @@ fun foo(): String = ""
class A {
fun foo() {}
fun main() {
val x = ::foo
compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt
Vendored
+2 -2
View File
@@ -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)
compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.fir.kt
Vendored
+4 -4
View File
@@ -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())<!>)
}
compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.fir.kt
Vendored
+1 -1
View File
@@ -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)
compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt
Vendored
+1 -1
View File
@@ -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)
compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.fir.kt
Vendored
+2 -2
View File
@@ -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)
compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.fir.kt
Vendored
+1 -1
View File
@@ -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!!<!>)
}
compiler/testData/diagnostics/tests/cast/bare/FromErrorType.fir.kt
Vendored
+1 -1
View File
@@ -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!!<!>)
}
compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.fir.kt
Vendored
+2 -2
View File
@@ -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<!>)
}
compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.fir.kt
Vendored
+2 -2
View File
@@ -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!!<!>)
}
compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.fir.kt
Vendored
+2 -2
View File
@@ -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<!>)
}
compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.fir.kt
Vendored
+1 -1
View File
@@ -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<!>)
compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
Vendored
+9 -9
View File
@@ -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")
compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt
Vendored
+2 -2
View File
@@ -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<!>)
compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.txt
Vendored
+1
View File
@@ -5,3 +5,4 @@ package a {
public fun foo(/*0*/ i: kotlin.Int, /*1*/ s: kotlin.String): kotlin.Unit
public fun test(): kotlin.Unit
}
compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.fir.kt
Vendored
+1 -1
View File
@@ -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<!>()
compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt
Vendored
+2 -2
View File
@@ -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
}
}
compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt
Vendored
+2 -2
View File
@@ -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) {}
compiler/testData/diagnostics/tests/dataFlow/EmptyIf.fir.kt
Vendored
+2 -2
View File
@@ -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?) {
compiler/testData/diagnostics/tests/dataFlow/IsExpression.fir.kt
Vendored
+1 -1
View File
@@ -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
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.fir.kt
Vendored
+4 -4
View File
@@ -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<!>)
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.fir.kt
Vendored
+4 -4
View File
@@ -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];
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt
Vendored
+1 -1
View File
@@ -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<!>];
}
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.fir.kt
Vendored
+1 -1
View File
@@ -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))
}

Some files were not shown because too many files have changed in this diff Show More