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

FIR: Update test data (repeated diagnostics)

Browse Source 
They are a bit redundant, but it needs additional work to be done
to avoid them
This commit is contained in:
Denis.Zharkov
2021-04-27 18:03:23 +03:00
committed by teamcityserver
parent dbc0ebd861
commit 00821bbc63
93 changed files with 306 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt
Vendored
+1 -1
View File
@@ -57,7 +57,7 @@ open class J() : S() {
}
open class Base<T : X, Z : T> {
open fun kek(): Z = <!RETURN_TYPE_MISMATCH!>Z()<!>
open fun kek(): Z = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>Z()<!>
}
open class GoodDerrived : Base<Y, W>() {
compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt
Vendored
+3 -3
View File
@@ -21,9 +21,9 @@ fun main() {
x.toInt().toString()
}
JavaUsage.foo2 { x: Int ->
<!ARGUMENT_TYPE_MISMATCH!>x.toString()<!>
}
JavaUsage.foo2 <!ARGUMENT_TYPE_MISMATCH!>{ x: Int ->
x.toString()
}<!>
JavaUsage.foo3(
{ x ->
compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt
Vendored
+2 -2
View File
@@ -29,10 +29,10 @@ fun main() {
foo1 { x -> x > 1 }
foo1(f)
foo2 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
foo2 <!ARGUMENT_TYPE_MISMATCH!>{ x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
foo2(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
foo3 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
foo3 <!ARGUMENT_TYPE_MISMATCH!>{ x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
foo3(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
foo4 { x -> x > 1 }
compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt
Vendored
+4 -5
View File
@@ -18,12 +18,11 @@ public class JavaUsage {
fun foo(m: MyRunnable) {}
fun main() {
JavaUsage.foo {
x ->
<!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!>
}
JavaUsage.foo <!ARGUMENT_TYPE_MISMATCH!>{
x -> x <!UNRESOLVED_REFERENCE!>><!> 1
}<!>
JavaUsage.foo({ <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> > 1<!> })
JavaUsage.foo(<!ARGUMENT_TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> > 1 }<!>)
val x = { x: Int -> x > 1 }
compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/functionReturnTypeMismatchChecker/basic.kt
Vendored
+2 -2
View File
@@ -12,7 +12,7 @@ fun ok(): Int {
}
fun okOneLineFunction(): Int = 10 + 1
fun errorOneLineFunction(): String = <!RETURN_TYPE_MISMATCH!>10 + 1<!>
fun errorOneLineFunction(): String = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>10 + 1<!>
class A {
fun bar() {}
@@ -52,4 +52,4 @@ fun blockReturnValueTypeMatch2() : Int {
if (1 > 2)
else return <!RETURN_TYPE_MISMATCH!>1.0<!>
return <!RETURN_TYPE_MISMATCH!>2.0<!>
}
}
compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out
Vendored
+3
View File
@@ -13,6 +13,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:32: error: argument type mismatch: actual type is kotlin/Int but kotlin/Function0<TypeVariable(_L)> was expected
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/diagnostics/tests/AutoCreatedIt.fir.kt
Vendored
+4 -4
View File
@@ -3,17 +3,17 @@ fun text() {
"direct:a" to "mock:a"
"direct:a" on {it.body == "<hello/>"} to "mock:a"
"direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
bar {<!ARGUMENT_TYPE_MISMATCH!>1<!>}
bar {<!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> + 1<!>}
bar <!ARGUMENT_TYPE_MISMATCH!>{1}<!>
bar <!ARGUMENT_TYPE_MISMATCH!>{<!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> + 1<!>}<!>
bar {it, it1 -> it}
bar1 {1}
bar1 {it + 1}
<!INAPPLICABLE_CANDIDATE!>bar2<!> {}
bar2 <!ARGUMENT_TYPE_MISMATCH!>{}<!>
bar2 {1}
bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
bar2 {<!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!ARGUMENT_TYPE_MISMATCH!>it<!>}
bar2 <!ARGUMENT_TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> it}<!>
}
fun bar(f : (Int, Int) -> Int) {}
compiler/testData/diagnostics/tests/Bounds.fir.kt
Vendored
+1 -1
View File
@@ -21,7 +21,7 @@ package boundsWithSubstitutors
class Pair<A, B>
abstract class C<T : B<Int>, X : (B<Char>) -> Pair<B<Any>, B<A>>>() : B<Any>() { // 2 errors
abstract class C<T : B<Int>, X : (B<Char>) -> Pair<B<Any>, B<A>>>() : <!UPPER_BOUND_VIOLATED!>B<Any><!>() { // 2 errors
val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error
abstract val x : (B<Char>) -> B<Any>
compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.fir.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ fun Int.gg() = null
fun ff() {
val a: Int = 1
val b: Int = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
val b: Int = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!><!TYPE_MISMATCH!>gg()<!><!>
}
compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ fun test1() {
bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
bar("", "", ::fooReturnInt).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Pair<String, Any>>() }
val x: String = <!INITIALIZER_TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
val x: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
}
compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt
Vendored
+3 -3
View File
@@ -29,9 +29,9 @@ fun <T> test(x: T) {
baz(1, null, ::foo)
baz(null, null, ::foo)
val s3: Pair<Int, String?> = bar(null, null, ::foo)
val s4: Pair<Int?, String> = <!INITIALIZER_TYPE_MISMATCH!>bar(null, null, ::foo)<!>
val s3: Pair<Int, String?> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::foo)<!>
val s4: Pair<Int?, String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::foo)<!>
val s5: Pair<Int, String> = <!INITIALIZER_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val s5: Pair<Int, String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.fir.kt
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ fun test1() {
baz<String>(::foo).checkType { _<String?>() }
baz<Boolean>(::foo).checkType { _<Boolean?>() }
val b1: Int = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b2: String = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b3: Boolean = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b1: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b2: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b3: Boolean = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
}
compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.fir.kt
Vendored
+3 -3
View File
@@ -20,6 +20,6 @@ public interface Executor {
fun f(): String = "test"
class A {
fun schedule1(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH!>e.submit(::f)<!>
fun schedule2(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH!>e.submit { f() }<!>
}
fun schedule1(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>e.submit(::f)<!>
fun schedule2(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>e.submit { f() }<!>
}
compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.fir.kt
Vendored
+3 -3
View File
@@ -20,12 +20,12 @@ operator fun Impl2.unaryMinus() = Impl2()
// See also KT-10384: in non-error functions, as is necessary!
fun add1(x: Impl2, y: Base): Impl1 = x as Base + y
fun error1(x: Impl2, y: Base): Impl1 = <!RETURN_TYPE_MISMATCH!>x + y<!>
fun error1(x: Impl2, y: Base): Impl1 = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
fun add2(x: Base, y: Impl2): Impl1 = x + y as Base
fun error2(x: Base, y: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH!>x + y<!>
fun error2(x: Base, y: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
fun minus3(x: Impl2): Impl1 = -(x as Base)
fun error3(x: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH!>-x<!>
fun error3(x: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>-x<!>
compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.fir.kt
Vendored
+16
View File
@@ -0,0 +1,16 @@
// FILE: J.java
public interface J {
String platformString();
}
// FILE: test.kt
fun f1(x: Int?): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>x<!>::class
fun <T> f2(t: T): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>t<!>::class
fun <T> f21(t: T): Any where T : Any?, T : Comparable<T> = t::class
fun <S : String?> f3(s: S): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>s<!>::class
fun <U : Any> f4(u: U?): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>u<!>::class
fun f5(c: List<*>): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, TYPE_MISMATCH!>c[0]<!>::class
fun f6(j: J): Any = j.platformString()::class
compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.kt
Vendored
-1
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// FILE: J.java
public interface J {
compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.fir.kt
Vendored
+1 -1
View File
@@ -12,7 +12,7 @@ public class J {
val testImplicitExclExcl1: String = J.s
val testImplicitExclExcl2: String? = J.s
val testImplicitExclExcl3: String = <!INITIALIZER_TYPE_MISMATCH!>J.m[""]<!>
val testImplicitExclExcl3: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>J.m[""]<!>
val testImplicitExclExcl4: String? = J.m[""]
val testExclExcl1: String = J.s!!
compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.fir.kt
Vendored
+1 -1
View File
@@ -9,4 +9,4 @@ open class Bar() : <!OTHER_ERROR!>Foo<!>() {
}
val x : Int = <!INITIALIZER_TYPE_MISMATCH!>Foo()<!>
val x : Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>Foo()<!>
compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.fir.kt
Vendored
+1 -1
View File
@@ -53,4 +53,4 @@ class CBarT<T> : IBarT<T> {
<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test7<!> : Final(), IBarT<Int> by CBarT<Int>()
<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by CBar()
<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by <!TYPE_MISMATCH!>CBar()<!>
compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.fir.kt
Vendored
+2 -2
View File
@@ -23,6 +23,6 @@ public abstract class MyClass : Base1, Base2 {
}
}
<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by Delegate2() {
<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!TYPE_MISMATCH!>Delegate2()<!> {
}
}
compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.fir.kt
Vendored
+19
View File
@@ -0,0 +1,19 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
// !WITH_NEW_INFERENCE
interface JPAEntityClass<D> {
fun <T> T.findByName(s: String): D {null!!}
}
class Foo {
companion object : JPAEntityClass<Foo>
}
fun main() {
with("", {
<!ARGUMENT_TYPE_MISMATCH!>Foo.<!UNRESOLVED_REFERENCE!>findByName<!>("")<!>
})
with(Foo) {
findByName("")
}
}
compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt
Vendored
-1
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_PARAMETER
// !WITH_NEW_INFERENCE
compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
// !WITH_NEW_INFERENCE
fun foo(f: String.() -> Int) {}
val test = foo(fun () = <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>length<!>)
val test = foo(<!ARGUMENT_TYPE_MISMATCH!>fun () = <!UNRESOLVED_REFERENCE!>length<!><!>)
compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.fir.kt
Vendored
+2 -2
View File
@@ -16,6 +16,6 @@ fun test(s: Sub) {
t: Trait -> s
}
foo(fun(t: Sub) = <!ARGUMENT_TYPE_MISMATCH!>s<!>)
foo(fun(t): Super = <!ARGUMENT_TYPE_MISMATCH!>s<!>)
foo(<!ARGUMENT_TYPE_MISMATCH!>fun(t: Sub) = s<!>)
foo(<!ARGUMENT_TYPE_MISMATCH!>fun(t): Super = s<!>)
}
compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.fir.kt
Vendored
+24 -24
View File
@@ -9,37 +9,37 @@ fun test1() {
foo0 {
""
}
foo0 {
s: String-> <!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo0 {
<!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo0 <!ARGUMENT_TYPE_MISMATCH!>{
s: String-> ""
}<!>
foo0 <!ARGUMENT_TYPE_MISMATCH!>{
<!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> ""
}<!>
foo1 {
""
}
foo1 <!ARGUMENT_TYPE_MISMATCH!>{
s: String -> ""
}<!>
foo1 <!ARGUMENT_TYPE_MISMATCH!>{
x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> ""
}<!>
foo1 {
s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo1 {
x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo1 {
-> 42
-> <!ARGUMENT_TYPE_MISMATCH!>42<!>
}
foo2 {
<!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo2 {
s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo2 {
x -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
}
foo2 {
foo2 <!ARGUMENT_TYPE_MISMATCH!>{
""
}<!>
foo2 <!ARGUMENT_TYPE_MISMATCH!>{
s: String -> ""
}<!>
foo2 <!ARGUMENT_TYPE_MISMATCH!>{
x -> ""
}<!>
foo2 <!ARGUMENT_TYPE_MISMATCH!>{
-> <!ARGUMENT_TYPE_MISMATCH!>42<!>
}
}<!>
}
compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ fun test(bal: Array<Int>) {
val e: Unit = run { bar += 4 }
val f: Int = <!INITIALIZER_TYPE_MISMATCH!>run { bar += 4 }<!>
val f: Int = <!INITIALIZER_TYPE_MISMATCH!>run <!TYPE_MISMATCH!>{ bar += 4 }<!><!>
}
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.fir.kt
Vendored
+2 -2
View File
@@ -27,8 +27,8 @@ fun bar(aList: List<A>) {
b checkType { _<String>() }
}
aList.<!INAPPLICABLE_CANDIDATE!>foo<!> { (a, b): B ->
aList.foo <!ARGUMENT_TYPE_MISMATCH!>{ (a, b): B ->
b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}
}<!>
}
compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ fun foo(x: A<String, Any?>, cs: CharSequence, ls: List<CharSequence>) {
y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>)
val s: String = <!INITIALIZER_TYPE_MISMATCH!>y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)<!>
val ls2: List<String> = <!INITIALIZER_TYPE_MISMATCH!>y.bar()<!>
val ls2: List<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>y.bar()<!>
}
compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.fir.kt
Vendored
+1 -1
View File
@@ -14,5 +14,5 @@ package p1
import p2.*
val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = <!INITIALIZER_TYPE_MISMATCH!>X()<!>
val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>X()<!>
val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!INVISIBLE_REFERENCE!>Y<!>()
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.fir.kt
Vendored
+2 -2
View File
@@ -147,7 +147,7 @@ fun poll73(): Flow<String> {
fun poll8(): Flow<String> {
return flow {
val inv = {1} in setOf({1f})
val inv = {<!ARGUMENT_TYPE_MISMATCH!>1<!>} in setOf({1f})
<!UNRESOLVED_REFERENCE!>inv<!>()
}
}
@@ -175,7 +175,7 @@ fun poll83(): Flow<String> {
fun poll84(): Flow<String> {
return flow {
val inv = {{1}} in setOf({{1f}})
val inv = {<!ARGUMENT_TYPE_MISMATCH!>{1}<!>} in setOf({{1f}})
<!UNRESOLVED_REFERENCE!>inv<!>()
}
}
compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.fir.kt
Vendored
+1 -1
View File
@@ -5,6 +5,6 @@ fun <T> foo(a1: Array<T>, a2: Array<out T>): T = null!!
fun test(a1: Array<in Int>, a2: Array<Int>) {
val c: Int = <!INITIALIZER_TYPE_MISMATCH!>foo(a1, a2)<!>
val c: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>foo(a1, a2)<!>
}
compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.fir.kt
Vendored
+2 -2
View File
@@ -12,7 +12,7 @@ fun foo(): String? {
run {
if (true) return@run
if (true) return <!RETURN_TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
if (true) return <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
}
run {
@@ -39,4 +39,4 @@ fun foo(): String? {
}
return ""
}
}
compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.fir.kt
Vendored
+1 -1
View File
@@ -42,7 +42,7 @@ fun test(i: Inv<Nothing>, iUnit: Inv<Unit>) {
}
launch {
@Suppress("UNSUPPORTED")
<!INAPPLICABLE_CANDIDATE!>run<!><dynamic> { "" }
run<dynamic> <!ARGUMENT_TYPE_MISMATCH!>{ "" }<!>
}
if (iUnit is String) {
compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.fir.kt
Vendored
+2 -2
View File
@@ -52,7 +52,7 @@ fun testUnit() {
fun testParameter() {
takeFnToParameter { }
takeFnToParameter { Unit }
takeFnToParameter { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
takeFnToParameter { <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!> }
takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
takeFnToParameter {
if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
@@ -66,7 +66,7 @@ fun testParameter() {
takeFnToParameter(fun(): Unit { return Unit })
takeFnToParameter(fun() { if (true) return })
takeFnToParameter(fun() { if (true) return Unit })
takeFnToParameter(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
takeFnToParameter(fun() = <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!>)
takeFnToParameter(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
takeFnToParameter(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
takeFnToParameter(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })
compiler/testData/diagnostics/tests/inference/completionOfMultipleLambdas.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
select3(
{ a: A, b: A -> Unit },
{ b, a -> Unit },
{ <!UNRESOLVED_REFERENCE!>it<!>; Unit }
<!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!>; Unit }<!>
)
}
compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt
Vendored
+1 -2
View File
@@ -3,10 +3,9 @@ package c
import java.util.ArrayList
fun Array<Int>.toIntArray(): IntArray = this.mapTo(<!ARGUMENT_TYPE_MISMATCH!>IntArray(size)<!>, {it})
fun Array<Int>.toIntArray(): IntArray = <!RETURN_TYPE_MISMATCH!>this.mapTo(<!ARGUMENT_TYPE_MISMATCH!>IntArray(size)<!>, {it})<!>
fun Array<Int>.toArrayList(): ArrayList<Int> = this.mapTo(ArrayList<Int>(size), {it})
public fun <T, R, C: MutableCollection<in R>> Array<out T>.mapTo(result: C, transform : (T) -> R) : C =
throw Exception("$result $transform")
compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt
Vendored
+1 -1
View File
@@ -16,6 +16,6 @@ class C<X, Z, Y : X>
class D<X, Z, Y : X>(foo: C<X, Z, Y>) {
fun test(a: C<Y, Y, Y>) {
val d: D<X, Y, Y> = <!INITIALIZER_TYPE_MISMATCH!>D(a)<!>
val d: D<X, Y, Y> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>D(a)<!>
}
}
compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt
Vendored
+7 -7
View File
@@ -25,17 +25,17 @@ fun test1(int: Int, any: Any) {
val a5 : MyList<in Int> = getMyListToWriteTo(any)
val a6 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Int>(int)<!>
val a6 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Int>(int)<!>
val a7 : MyList<in Any> = getMyList(int)
val a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
val a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
val a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Any>(any)<!>
val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList(any)<!>
val a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
val a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
val a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
useMyList(getMyList(int), int)
useMyList(getMyList(any), int)
compiler/testData/diagnostics/tests/inference/kt1293.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ package kt1293
fun main() {
val intArray = arrayOfNulls<Int>(10)
val i : Int = <!INITIALIZER_TYPE_MISMATCH!>intArray[0]<!>
val i : Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>intArray[0]<!>
requiresInt(<!ARGUMENT_TYPE_MISMATCH!>intArray[0]<!>)
}
compiler/testData/diagnostics/tests/inference/kt28654.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
// Related issue: KT-28654
fun <K> select(): K = <!RETURN_TYPE_MISMATCH!>run { }<!>
fun <K> select(): K = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>run { }<!>
fun test() {
val x: Int = select()
compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.fir.kt
Vendored
+2 -2
View File
@@ -15,7 +15,7 @@ fun testAny() {
fun testAnyCall() {
callAny {
error -> <!UNRESOLVED_REFERENCE!>error<!>()
error -> <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>error<!>()<!>
}
}
@@ -27,7 +27,7 @@ fun testParam() {
fun testParamCall() {
callParam {
param -> <!UNRESOLVED_REFERENCE!>param<!>()
param -> <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>param<!>()<!>
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ package d
fun <T> asList(t: T) : List<T>? {}
fun main() {
val list : List<String> = <!INITIALIZER_TYPE_MISMATCH!>asList("")<!>
val list : List<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>asList("")<!>
}
compiler/testData/diagnostics/tests/inference/regressions/kt2741.fir.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ fun <T> _arrayList(vararg values: T) : List<T> = throw Exception()
class _Pair<A>(val a: A)
fun test() {
_arrayList(_Pair(1))._sortBy { it -> <!UNRESOLVED_REFERENCE!>xxx<!> }
_arrayList(_Pair(1))._sortBy { it -> <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xxx<!> }
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841.fir.kt
Vendored
+17
View File
@@ -0,0 +1,17 @@
// !WITH_NEW_INFERENCE
package a
interface Closeable {}
class C : Closeable {}
public inline fun <T: Closeable, R> T.use1(block: (T)-> R) : R {
return block(this)
}
fun main() {
C().use1 {
w -> // ERROR here
<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt
Vendored
-1
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
package a
compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.fir.kt
Vendored
+20
View File
@@ -0,0 +1,20 @@
// !WITH_NEW_INFERENCE
package a
interface Closeable {
fun close() {}
}
class C : Closeable
public inline fun <T: Closeable, R> T.use(block: (t: T)-> R) : R {
return block(this)
}
fun test() {
C().use {
it.close()
<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
package a
@@ -18,4 +17,4 @@ fun test() {
it.close()
<!UNRESOLVED_REFERENCE!>x<!>
}
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.fir.kt
Vendored
+21
View File
@@ -0,0 +1,21 @@
// !WITH_NEW_INFERENCE
package a
interface Closeable {
fun close() {}
}
class C : Closeable
public inline fun <T: Closeable, R> use(t: T, block: T.(T)-> R) : R {
return t.block(t)
}
fun test() {
use(C()) {
this.close()
it.close()
<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xx<!>
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
package a
@@ -19,4 +18,4 @@ fun test() {
it.close()
<!UNRESOLVED_REFERENCE!>xx<!>
}
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.fir.kt
Vendored
+20
View File
@@ -0,0 +1,20 @@
// !WITH_NEW_INFERENCE
package a
interface Closeable {
fun close() {}
}
class C : Closeable
public inline fun <T: Closeable, R> T.use(block: T.()-> R) : R {
return this.block()
}
fun test() {
C().use {
this.close()
<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.kt
Vendored
+1 -2
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
package a
@@ -18,4 +17,4 @@ fun test() {
this.close()
<!UNRESOLVED_REFERENCE!>x<!>
}
}
}
compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt
Vendored
+2 -2
View File
@@ -22,12 +22,12 @@ fun test() {
doAction { bar(12) }
val u: Unit = <!INITIALIZER_TYPE_MISMATCH!>bar(11)<!>
val u: Unit = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar(11)<!>
}
fun testWithoutInference(col: MutableCollection<Int>) {
doAction { col.add(2) }
val u: Unit = <!INITIALIZER_TYPE_MISMATCH!>col.add(2)<!>
val u: Unit = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>col.add(2)<!>
}
compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt
Vendored
+3 -3
View File
@@ -7,9 +7,9 @@ fun <T, R> foo(a: A<T, R>) = a
fun <T, R> bar(f: (T) -> R) = f
fun test() {
foo { <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }
foo { x -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
foo { x: Int -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
foo <!ARGUMENT_TYPE_MISMATCH!>{ <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }<!>
foo <!ARGUMENT_TYPE_MISMATCH!>{ x -> x}<!>
foo <!ARGUMENT_TYPE_MISMATCH!>{ x: Int -> x}<!>
bar { it <!UNRESOLVED_REFERENCE!>+<!> 1 }
bar { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1}
compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.fir.kt
Vendored
+17
View File
@@ -0,0 +1,17 @@
// !WITH_NEW_INFERENCE
package a
interface Closeable {}
class C : Closeable {}
fun <T: Closeable, R> T.foo(block: (T)-> R) = block
fun <T: Closeable, R> T.foo(block: (T, T)-> R) = block
fun main() {
C().foo { // no ambiguity here
www ->
<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xs<!>
}
}
compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt
Vendored
-1
View File
@@ -1,4 +1,3 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
package a
compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt
Vendored
+6 -6
View File
@@ -16,13 +16,13 @@ public interface J2 extends J {
// FILE: main.kt
fun main() {
J { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>} // should be prohibited, because SAM value parameter has nullable type
J <!ARGUMENT_TYPE_MISMATCH!>{ s: String -> s}<!> // should be prohibited, because SAM value parameter has nullable type
J { "" + it<!UNSAFE_CALL!>.<!>length }
J { null }
J { it?.length?.toString() }
J { <!NULL_FOR_NONNULL_TYPE!>null<!> }
J { it?.length?.<!ARGUMENT_TYPE_MISMATCH!>toString()<!> }
J2 { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>}
J2 <!ARGUMENT_TYPE_MISMATCH!>{ s: String -> s}<!>
J2 { "" + it<!UNSAFE_CALL!>.<!>length }
J2 { null }
J2 { it?.length?.toString() }
J2 { <!NULL_FOR_NONNULL_TYPE!>null<!> }
J2 { it?.length?.<!ARGUMENT_TYPE_MISMATCH!>toString()<!> }
}
compiler/testData/diagnostics/tests/library/Collections.fir.kt
Vendored
+5 -5
View File
@@ -8,7 +8,7 @@ fun <T> testCollection(c: Collection<T>, t: T) {
val iterator: Iterator<T> = c.iterator()
c.containsAll(c)
val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>c.iterator()<!>
val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>c.iterator()<!>
c.<!UNRESOLVED_REFERENCE!>add<!>(t)
c.<!UNRESOLVED_REFERENCE!>remove<!>(1)
c.<!UNRESOLVED_REFERENCE!>addAll<!>(c)
@@ -45,9 +45,9 @@ fun <T> testList(l: List<T>, t: T) {
val value: T = l.<!UNRESOLVED_REFERENCE!>set<!>(1, t)
l.<!UNRESOLVED_REFERENCE!>add<!>(1, t)
l.<!UNRESOLVED_REFERENCE!>remove<!>(1)
val mutableListIterator: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>l.listIterator()<!>
val mutableListIterator1: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>l.listIterator(1)<!>
val mutableList: MutableList<T> = <!INITIALIZER_TYPE_MISMATCH!>l.subList(1, 2)<!>
val mutableListIterator: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>l.listIterator()<!>
val mutableListIterator1: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>l.listIterator(1)<!>
val mutableList: MutableList<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>l.subList(1, 2)<!>
}
fun <T> testMutableList(l: MutableList<T>, t: T) {
@@ -66,7 +66,7 @@ fun <T> testSet(s: Set<T>, t: T) {
val iterator: Iterator<T> = s.iterator()
s.containsAll(s)
val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>s.iterator()<!>
val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>s.iterator()<!>
s.<!UNRESOLVED_REFERENCE!>add<!>(t)
s.<!UNRESOLVED_REFERENCE!>remove<!>(1)
s.<!UNRESOLVED_REFERENCE!>addAll<!>(s)
compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.fir.kt
Vendored
+1 -1
View File
@@ -21,5 +21,5 @@ fun test() {
val d = either(11, 2.3)
checkSubtype<Any>(d)
val e: Float = <!INITIALIZER_TYPE_MISMATCH!>id(1)<!>
val e: Float = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>id(1)<!>
}
compiler/testData/diagnostics/tests/regressions/OutProjections.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ fun <T> f(expression : T) : G<out T> = G<T>()
fun foo() : G<Point> {
val p = Point()
return <!RETURN_TYPE_MISMATCH!>f<Point>(p)<!>
return <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>f<Point>(p)<!>
}
class Out<out T>() {}
compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.fir.kt
Vendored
+2 -2
View File
@@ -8,9 +8,9 @@ fun main() {
val g1 : String = ++v;
val h : String = v--;
val h1 : String = --v;
val i : String = <!INITIALIZER_TYPE_MISMATCH!>!true<!>;
val i : String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>!true<!>;
val j : String = <!INITIALIZER_TYPE_MISMATCH!>foo@ true<!>;
val k : String = <!INITIALIZER_TYPE_MISMATCH!>foo@ bar@ true<!>;
val l : String = <!INITIALIZER_TYPE_MISMATCH!>-1<!>;
val m : String = <!INITIALIZER_TYPE_MISMATCH!>+1<!>;
}
}
compiler/testData/diagnostics/tests/regressions/kt312.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun <T> Array<out T>.safeGet(index : Int) : T? {
}
val args : Array<String> = Array<String>(1, {""})
val name : String = <!INITIALIZER_TYPE_MISMATCH!>args.safeGet<String>(0)<!> // No error, must be type mismatch
val name : String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>args.safeGet<String>(0)<!> // No error, must be type mismatch
val name1 : String? = args.safeGet(0)
compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.fir.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ fun overloadedFun1(c: Any = "", b: String = "", f: Any = "") = Right
fun overloadedFun1(b: Any = "", c: Any = "", e: String = "") = Wrong
val test1: Right = overloadedFun1(b = "")
val test1a: Wrong = <!INITIALIZER_TYPE_MISMATCH!>overloadedFun1(b = "")<!>
val test1a: Wrong = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>overloadedFun1(b = "")<!>
fun overloadedFun2(a: String, b: Any = "") = Right
fun overloadedFun2(a: Any, b: String = "") = Wrong
compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.fir.kt
Vendored
+1 -2
View File
@@ -16,7 +16,7 @@ fun <T> LiveData<T>.observe(a: Any, observer: (T) -> Unit): Observer<T> {
}
// FILE: test.kt
fun <T> test1(r: Runnable, l: LiveData<T>): Observer<T> = <!RETURN_TYPE_MISMATCH!>l.observe(r) { }<!> // partial conversion
fun <T> test1(r: Runnable, l: LiveData<T>): Observer<T> = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>l.observe(r) { }<!> // partial conversion
fun <T> test2(r: Runnable, o: Observer<T>, l: LiveData<T>) {
val a = l.observe(r, o) // no conversion
@@ -28,4 +28,3 @@ fun <T> test2(r: Runnable, o: Observer<T>, l: LiveData<T>) {
val c = l.observe({}) {} // conversion for all arguments
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>c<!>
}
compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt
Vendored
+2 -2
View File
@@ -20,7 +20,7 @@ fun test() {
class B: A() {
init {
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>foo()<!> // todo
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
}
}
}
@@ -31,4 +31,4 @@ class E: A() {
init {
val a: A = foo() // todo: discuss
}
}
}
compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt
Vendored
+2 -2
View File
@@ -12,14 +12,14 @@ open class A<T> : J() {
init {
foo()
bar()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
fun test1() {
foo()
bar()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt
Vendored
+2 -2
View File
@@ -12,14 +12,14 @@ open class A<T> : J() {
init {
foo()
bar()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
fun test1() {
foo()
bar()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt
Vendored
+2 -2
View File
@@ -21,7 +21,7 @@ fun test() {
class B: A() {
init {
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>foo()<!> // todo
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
}
}
}
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.fir.kt
Vendored
+2 -2
View File
@@ -7,9 +7,9 @@ class A {
constructor(x: () -> Int)
constructor() : this(
{
<!UNRESOLVED_REFERENCE!>foo<!>() +
<!ARGUMENT_TYPE_MISMATCH, TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>foo<!>() +
<!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() +
<!UNRESOLVED_LABEL!>this@A<!>.<!UNRESOLVED_REFERENCE!>foo<!>() +
<!UNRESOLVED_REFERENCE!>foobar<!>()
<!UNRESOLVED_REFERENCE!>foobar<!>()<!>
})
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt
Vendored
+1 -1
View File
@@ -2,6 +2,6 @@
class A {
fun foo() = 1
constructor(x: Int)
constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()) :
constructor(x: Int, y: Int, z: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()<!>) :
this(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt
Vendored
+1 -1
View File
@@ -2,6 +2,6 @@
class A {
val prop = 1
constructor(x: Int)
constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
constructor(x: Int, y: Int, z: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>) :
this(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>)
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt
Vendored
+1 -1
View File
@@ -2,6 +2,6 @@
open class B(x: Int)
class A : B {
val prop = 1
constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>) :
super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>)
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt
Vendored
+1 -1
View File
@@ -3,6 +3,6 @@ open class B(x: Int) {
fun foo() = 1
}
class A : B {
constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>) :
super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt
Vendored
+1 -1
View File
@@ -4,6 +4,6 @@ open class B(x: Int) {
}
class A : B {
override fun foo() = 2
constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>) :
super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
}
compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
open class B(val prop: Int)
class A : B {
constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>) :
constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!><!>) :
super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!><!>)
}
compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt
Vendored
+1 -1
View File
@@ -31,7 +31,7 @@ fun test(a: A, b: B, c: C) {
val k = three(a, b, c)
checkSubtype<A>(k)
checkSubtype<B>(<!ARGUMENT_TYPE_MISMATCH!>k<!>)
val l: Int = <!INITIALIZER_TYPE_MISMATCH!>three(a, b, c)<!>
val l: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>three(a, b, c)<!>
use(d, e, f, g, h, k, l)
}
compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// JAVAC_EXPECTED_FILE
// FILE: KotlinFile.kt
fun foo(javaClass: JavaClass<String>): String {
return javaClass.doSomething("", 1) { s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!> }
return javaClass.doSomething("", 1) <!ARGUMENT_TYPE_MISMATCH!>{ s: String -> "" }<!>
}
// FILE: JavaClass.java
compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
// JAVAC_EXPECTED_FILE
// FILE: KotlinFile.kt
fun foo(javaClass: JavaClass): String {
return javaClass.doSomething("") { <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }
return javaClass.doSomething("") <!ARGUMENT_TYPE_MISMATCH!>{ <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }<!>
}
// FILE: JavaClass.java
compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt
Vendored
+2 -2
View File
@@ -2,8 +2,8 @@
// JAVAC_EXPECTED_FILE
// FILE: KotlinFile.kt
fun foo(javaClass: JavaClass<Int>) {
val a: String = javaClass.doSomething1("", 1) { p: String -> <!ARGUMENT_TYPE_MISMATCH!>p<!> }
val b: String = javaClass.doSomething2("", 1, true) { p: Int -> <!ARGUMENT_TYPE_MISMATCH!>p<!> }
val a: String = javaClass.doSomething1("", 1) <!ARGUMENT_TYPE_MISMATCH!>{ p: String -> p }<!>
val b: String = javaClass.doSomething2("", 1, true) <!ARGUMENT_TYPE_MISMATCH!>{ p: Int -> p }<!>
}
// FILE: JavaClass.java
compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt
Vendored
+4 -4
View File
@@ -16,9 +16,9 @@ fun foo(javaClass: JavaClass, kotlinClass: KotlinClass) {
bar()
}
javaClass.doSomething2 {
<!ARGUMENT_TYPE_MISMATCH!>bar()<!>
}
javaClass.doSomething2 <!ARGUMENT_TYPE_MISMATCH!>{
bar()
}<!>
}
fun bar(){}
@@ -27,4 +27,4 @@ fun bar(){}
public class JavaClass {
public void doSomething(Runnable runnable) { runnable.run(); }
public void doSomething2(I i) { i.doIt(); }
}
}
compiler/testData/diagnostics/tests/typeParameters/dontIntersectUpperBoundWithExpectedType.fir.kt
Vendored
+2 -2
View File
@@ -9,9 +9,9 @@ fun <T : Foo> foo(): T? {
}
fun main() {
val a: Bar? = <!DEBUG_INFO_EXPRESSION_TYPE("Foo? & Bar?")!>foo()<!>
val a: Bar? = <!DEBUG_INFO_EXPRESSION_TYPE("Foo?"), INITIALIZER_TYPE_MISMATCH, NEW_INFERENCE_ERROR!>foo()<!>
}
fun <T : Appendable> wtf(): T = TODO()
val bar: Int = wtf() // happily compiles
val bar: Int = <!INITIALIZER_TYPE_MISMATCH, NEW_INFERENCE_ERROR!>wtf()<!> // happily compiles
compiler/testData/diagnostics/tests/typeParameters/kt42042.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ sealed class Subtype<A1, B1> {
}
fun <A, B> unsafeCast(value: A): B {
val proof: Subtype<A, B> = <!UPPER_BOUND_VIOLATED!>Subtype.Trivial()<!>
val proof: Subtype<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Subtype.Trivial()<!>
return proof.cast(value)
}
compiler/testData/diagnostics/tests/typeParameters/kt42042Error.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ sealed class Subtype<A1, B1> {
}
fun <A, B> unsafeCast(value: A): B {
val proof: Subtype<A, B> = <!UPPER_BOUND_VIOLATED!>Subtype.Trivial()<!>
val proof: Subtype<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH!>Subtype.Trivial()<!>
return proof.cast(value)
}
compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.fir.kt
Vendored
+1 -1
View File
@@ -13,6 +13,6 @@ class TColl<T, C : Collection<T>>
typealias TC<T, C> = TColl<T, C>
typealias TC2<T, C> = TC<T, C>
val y1 = TColl<Any, <!UPPER_BOUND_VIOLATED!>Any<!>>()
val y1 = TColl<Any, <!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>()
val y2 = TC<Any, Any>()
val y3 = TC2<Any, Any>()
compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt
Vendored
+1 -1
View File
@@ -15,5 +15,5 @@ public class P {
fun foo(c: P): MutableList<Int> {
// Error should be here: see KT-8168 Typechecker fails for platform collection type
return <!RETURN_TYPE_MISMATCH!>c.getList() ?: listOf()<!>
return <!RETURN_TYPE_MISMATCH!>c.getList() ?: <!TYPE_MISMATCH!>listOf()<!><!>
}
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.fir.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!
fun test(map: Map<Int, String>) {
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>listOf(1).contains1("")<!>
val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>listOf(1).contains1("")<!>
val b: Boolean = listOf(1).contains1(1)
val c: String? = map.get1("")
compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt
Vendored
+2 -2
View File
@@ -19,7 +19,7 @@ fun main() {
val x1: suspend (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
// Here, the error should be
val x2: (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
val x2: (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id <!TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>"), TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)
val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id <!TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>"), TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)
val x4: (Int) -> Unit = takeSimpleFunction(<!ARGUMENT_TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Int, kotlin.Unit>")!>{}<!>)
}
compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt
Vendored
+2 -2
View File
@@ -3,10 +3,10 @@ abstract class KFunctionKt9005WorkAround<out R: Any?>(private val _functionInsta
private val _reflectedFunction: kotlin.reflect.KFunction<R> = _functionInstance.<!UNRESOLVED_REFERENCE!>reflect<!>() ?: throw IllegalStateException("")
private val _parameters: List<kotlin.reflect.KParameter> = run {
_functionInstance.javaClass.methods.first().<!UNRESOLVED_REFERENCE!>parameters<!>.map {
<!ARGUMENT_TYPE_MISMATCH!>_functionInstance.javaClass.methods.first().<!UNRESOLVED_REFERENCE!>parameters<!>.map {
<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : kotlin.reflect.KParameter {
override val index: Int = 0
}
}
}<!>
}
}
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.fir.kt
Vendored
+6 -6
View File
@@ -26,8 +26,8 @@ fun hashMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
@@ -50,8 +50,8 @@ fun treeMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
@@ -74,8 +74,8 @@ fun concurrentHashMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.fir.kt
Vendored
+5 -5
View File
@@ -25,9 +25,9 @@ fun hashMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x[null]<!>
val b8: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[null]<!>
val b8: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b9: Int? = x.get("")
}
@@ -50,8 +50,8 @@ fun treeMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.fir.kt
Vendored
+4 -4
View File
@@ -25,8 +25,8 @@ fun hashMapTest() {
val b4: Map<String, Int?> = x
val b5: Map<String?, Int?> = x
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
@@ -49,8 +49,8 @@ fun treeMapTest() {
val b4: Map<String, Int?> = x
val b5: Map<String?, Int?> = x
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
compiler/testData/diagnostics/testsWithStdLib/when/kt10807.fir.kt
Vendored
+2 -2
View File
@@ -10,8 +10,8 @@ fun getComp(): Comparator<Foo?> =
}<!>
fun getCompInverted(): Comparator<Foo?> =
nullsLast(
<!TYPE_MISMATCH!>nullsLast(
when {
else -> compareBy({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> })
}
)
)<!>
compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/72.fir.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ fun case_1() {
val strs = list as MutableList<String>
strs.add("two")
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableList<kotlin.String> & kotlin.collections.MutableList<kotlin.Int> & kotlin.collections.MutableList<kotlin.String>")!>list<!>
val s: String = <!INITIALIZER_TYPE_MISMATCH!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableList<kotlin.String> & kotlin.collections.MutableList<kotlin.Int> & kotlin.collections.MutableList<kotlin.String>")!>list<!>[0]<!>
val s: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableList<kotlin.String> & kotlin.collections.MutableList<kotlin.Int> & kotlin.collections.MutableList<kotlin.String>")!>list<!>[0]<!>
}
idea/testData/checker/trivialHierarchyLoop.fir.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
class A : <error descr="[OTHER_ERROR] Unknown (other) error">A</error>() {}
val x : Int = <error descr="[INITIALIZER_TYPE_MISMATCH] Initializer type mismatch: expected kotlin/Int, actual A">A()</error>
val x : Int = <error descr="[INITIALIZER_TYPE_MISMATCH] Initializer type mismatch: expected kotlin/Int, actual A"><error descr="[TYPE_MISMATCH] Type mismatch: inferred type is A but kotlin/Int was expected">A()</error></error>