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!>""<!>)
}