Introduce FirInitializerTypeMismatchChecker

2021-03-01 19:29:59 +03:00
parent 7ed35e5c2b
commit 24f1f1221e
114 changed files with 647 additions and 285 deletions
@@ -5,7 +5,7 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!

 fun test1(a: Array<out Int>) {
-    val r: Array<out Int?> = bar(a)
+    val r: Array<out Int?> = <!INITIALIZER_TYPE_MISMATCH!>bar(a)<!>
    val t = bar(a)
    t checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out Int?>>() }
 }
@@ -13,7 +13,7 @@ fun test1(a: Array<out Int>) {
 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!

 fun test2(a: Array<out Int>) {
-    val r: Array<out Array<out Int?>> = foo(a)
+    val r: Array<out Array<out Int?>> = <!INITIALIZER_TYPE_MISMATCH!>foo(a)<!>
    val t = foo(a)
    t checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out Array<out Int?>>>() }
 }
@@ -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 = foo(a1, a2)
+    val c: Int = <!INITIALIZER_TYPE_MISMATCH!>foo(a1, a2)<!>

 }
@@ -10,9 +10,9 @@ fun noCoercionLastExpressionUsedAsReturnArgument() {
 }

 fun noCoercionBlockHasExplicitType() {
-    val b: () -> Int = {
+    val b: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
        if (true) 42
-    }
+    }<!>
 }

 fun noCoercionBlockHasExplicitReturn() {
@@ -138,7 +138,7 @@ fun main() {
     * K <: (C) -> Unit -> TypeVariable(_RP1) >: C
     * K == (B) -> Unit -> TypeVariable(_RP1) == B
     */
-    val x17: (C) -> Unit = selectB(id { <!DEBUG_INFO_EXPRESSION_TYPE("B")!>it<!> }, id { it }, id<(B) -> Unit> { x -> x })
+    val x17: (C) -> Unit = <!INITIALIZER_TYPE_MISMATCH!>selectB(id { <!DEBUG_INFO_EXPRESSION_TYPE("B")!>it<!> }, id { it }, id<(B) -> Unit> { x -> x })<!>
    val x18: (C) -> Unit = select(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id<(B) -> Unit> { x -> x })

    // Resolution of extension/non-extension functions combination
@@ -153,7 +153,7 @@ fun main() {
    // Convert to extension lambda is impossible because the lambda parameter types aren't specified explicitly
    select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x, y -> x })
    select(id(id(fun(x: String, y: String) { }), <!TOO_MANY_ARGUMENTS!>fun String.(x: String) {}<!>), { x, y -> x })
-    val x26: Int.(String) -> Int = fun (x: String) = 10 // it must be error, see KT-38439
+    val x26: Int.(String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!> // it must be error, see KT-38439
    // Receiver must be specified in anonymous function declaration
    val x27: Int.(String) -> Int = id(fun (x: String) = 10)
    select(id<Int.(String) -> Unit> {}, { x: Int, y: String -> x })
@@ -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> = D(a)
+        val d: D<X, Y, Y> = <!INITIALIZER_TYPE_MISMATCH!>D(a)<!>
    }
 }
@@ -25,17 +25,17 @@ fun test1(int: Int, any: Any) {
    val a5 : MyList<in Int> = getMyListToWriteTo(any)


-    val a6 : MyList<in Any> = getMyList<Int>(int)
+    val a6 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Int>(int)<!>
    val a7 : MyList<in Any> = getMyList(int)

-    val a8 : MyList<in Any> = getMyListToReadFrom<Int>(int)
-    val a9 : MyList<in Any> = getMyListToReadFrom(int)
+    val a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
+    val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom(int)<!>

-    val a10 : MyList<out Int> = getMyList<Any>(any)
-    val a11 : MyList<out Int> = getMyList(any)
+    val a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Any>(any)<!>
+    val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList(any)<!>

-    val a12 : MyList<out Int> = getMyListToWriteTo<Any>(any)
-    val a13 : MyList<out Int> = getMyListToWriteTo(any)
+    val a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
+    val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo(any)<!>

    useMyList(getMyList(int), int)
    useMyList(getMyList(any), int)
@@ -5,7 +5,7 @@ package kt1293

 fun main() {
    val intArray = arrayOfNulls<Int>(10)
-    val i : Int = intArray[0]
+    val i : Int = <!INITIALIZER_TYPE_MISMATCH!>intArray[0]<!>
    requiresInt(<!ARGUMENT_TYPE_MISMATCH!>intArray[0]<!>)
 }

@@ -5,5 +5,5 @@ val test2f: suspend Any.() -> Unit = fun Any.() {}

 // This is a bug in the old inference and should be fixed in new inference
 // see "Fix anonymous function literals handling in type checker" for more details
-val test3f: suspend Any.(Int) -> Int = fun (k: Int) = k + 1
-val test4f: SuspendFn = fun Any.() {}
+val test3f: suspend Any.(Int) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
+val test4f: SuspendFn = <!INITIALIZER_TYPE_MISMATCH!>fun Any.() {}<!>
@@ -6,5 +6,5 @@ package d
 fun <T> asList(t: T) : List<T>? {}

 fun main() {
-    val list : List<String> = asList("")
+    val list : List<String> = <!INITIALIZER_TYPE_MISMATCH!>asList("")<!>
 }
@@ -22,12 +22,12 @@ fun test() {

    doAction { bar(12) }

-    val u: Unit =  bar(11)
+    val u: Unit =  <!INITIALIZER_TYPE_MISMATCH!>bar(11)<!>
 }

 fun testWithoutInference(col: MutableCollection<Int>) {

    doAction { col.add(2) }

-    val u: Unit = col.add(2)
+    val u: Unit = <!INITIALIZER_TYPE_MISMATCH!>col.add(2)<!>
 }
@@ -20,7 +20,7 @@ fun <X> InvBase<X>.myLastInv(): X = TODO()

 fun <T> fooInv(x: InvBase<T>) {
    if (x is InvDerived<*>) {
-        val l: T = x.<!INAPPLICABLE_CANDIDATE!>myLastInv<!>() // required T, found Cap(*). Only in NI
+        val l: T = <!INITIALIZER_TYPE_MISMATCH!>x.<!INAPPLICABLE_CANDIDATE!>myLastInv<!>()<!> // required T, found Cap(*). Only in NI
    }
 }

@@ -4,7 +4,7 @@ package typeInferenceExpectedTypeMismatch
 import java.util.*

 fun test() {
-    val s : Set<Int> = newList()
+    val s : Set<Int> = <!INITIALIZER_TYPE_MISMATCH!>newList()<!>
    use(s)
 }

@@ -35,7 +35,7 @@ fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
 fun test2(outA: Out<A>, inC: In<C>) {
    bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)

-    val b: Two<A, B> = bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)
+    val b: Two<A, B> = <!INITIALIZER_TYPE_MISMATCH!>bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)<!>
    use(b)
 }

@@ -8,5 +8,5 @@ class Client<T, X: Base<T>>(x: X)

 fun test() {
    val c = Client(StringBase()) // Type inference fails here for T.
-    val i : Int = c
+    val i : Int = <!INITIALIZER_TYPE_MISMATCH!>c<!>
 }