Report 'TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH'

on call element, not on callee expression
2015-10-17 16:55:50 +03:00
parent 4c85b69c88
commit bb9f7094e0
24 changed files with 36 additions and 36 deletions
@@ -20,6 +20,6 @@ class D : A<Int> by baz({ it + 1 })

 fun <T> boo(t: T): A<T> = AImpl()

-class E : A<Int> by <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>boo<!>("")
+class E : A<Int> by <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>boo("")<!>

 class F : A<Int> by <!TYPE_MISMATCH!>AImpl<String>()<!>
@@ -11,6 +11,6 @@ fun test(bal: Array<Int>) {

    val <!UNUSED_VARIABLE!>e<!>: Unit = run { bar += 4 }

-    val <!UNUSED_VARIABLE!>f<!>: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>run<!> { bar += 4 }
+    val <!UNUSED_VARIABLE!>f<!>: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>run { bar += 4 }<!>
 }
 fun <T> run(f: () -> T): T = f()
@@ -7,10 +7,10 @@ val a : (Int?) -> Int = l@ {

 fun <R> let(<!UNUSED_PARAMETER!>f<!>: (Int?) -> R): R = null!!

-val b: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>let<!> {
+val b: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>let {
    if (it != null) return@let it
    5
-}
+}<!>

 val c: Int = let {
    if (it != null) <!DEBUG_INFO_SMARTCAST!>it<!> else 5
@@ -4,6 +4,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 = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH(kotlin.Int; kotlin.Any?)!>foo<!>(a1, a2)
+    val c: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH(kotlin.Int; kotlin.Any?)!>foo(a1, a2)<!>

 }
@@ -15,6 +15,6 @@ class C<X, Z, Y : X>

 class D<X, Z, Y : X>(<!UNUSED_PARAMETER!>foo<!>: C<X, Z, Y>) {
    fun test(a: C<Y, Y, Y>) {
-        val d: D<X, Y, Y> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>D<!>(a)
+        val d: D<X, Y, Y> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>D(a)<!>
    }
 }
@@ -13,7 +13,7 @@ fun <T> readFromMyList(<!UNUSED_PARAMETER!>l<!>: MyList<out T>, <!UNUSED_PARAMET
 fun test1(int: Int, any: Any) {
    val a0 : MyList<Any> = getMyList(int)

-    val a1 : MyList<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyList<!>(any)
+    val a1 : MyList<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyList(any)<!>

    val a2 : MyList<out Any> = getMyList(int)

@@ -28,13 +28,13 @@ fun test1(int: Int, any: Any) {
    val a7 : MyList<in Any> = getMyList(int)

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

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

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

    useMyList(getMyList(int), int)
    useMyList(getMyList(any), int)
@@ -42,9 +42,9 @@ fun test1(int: Int, any: Any) {

    readFromMyList(getMyList(int), any)
    readFromMyList(getMyList(any), int)
-    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyList<!>(any), int)
+    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyList(any)<!>, int)

-    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyListToReadFrom<!>(any), int)
+    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyListToReadFrom(any)<!>, int)
    readFromMyList(getMyListToReadFrom(any), int)

    readFromMyList(getMyListToReadFrom(int), any)
@@ -9,5 +9,5 @@ fun <A, B> Foo<A>.map(<!UNUSED_PARAMETER!>f<!>: (A) -> B): Foo<B> = object : Foo

 fun foo() {
    val l: Foo<String> = object : Foo<String> {}
-    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map<!> { ppp -> 1 }
+    val <!UNUSED_VARIABLE!>m<!>: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>map { ppp -> 1 }<!>
 }
@@ -21,7 +21,7 @@ fun test() {
    
    doAction { bar(12) }

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

 fun testWithoutInference(col: MutableCollection<Int>) {
@@ -13,6 +13,6 @@ fun <T, G> A<T>.foo(x: (T)-> G): G {

 fun main(args: Array<String>) {
    val a = A(1)
-    val t: String = a.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo<!>({p -> p})
+    val t: String = a.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo({p -> p})<!>
    checkSubtype<String>(t)
 }
@@ -3,7 +3,7 @@ package typeInferenceExpectedTypeMismatch
 import java.util.*

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

@@ -25,7 +25,7 @@ fun <T, R> foo(o: Out<T>, i: In<R>): Two<T, R> = throw Exception("$o $i")
 fun test1(outA: Out<A>, inB: In<B>) {
    foo(outA, inB)

-    val b: Two<A, C> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo<!>(outA, inB)
+    val b: Two<A, C> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo(outA, inB)<!>
    use(b)
 }

@@ -18,5 +18,5 @@ fun test() {
    val d = either(11, 2.3)
    checkSubtype<Any>(d)

-    val <!UNUSED_VARIABLE!>e<!>: Float = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id<!>(1)
+    val <!UNUSED_VARIABLE!>e<!>: Float = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id(1)<!>
 }
@@ -12,9 +12,9 @@ fun <T> otherGeneric(<!UNUSED_PARAMETER!>l<!>: List<T>) {}
 fun test() {
    val a: Byte = id(1)

-    val b: Byte = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id<!>(300)
+    val b: Byte = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id(300)<!>

-    val c: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id<!>(9223372036854775807)
+    val c: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>id(9223372036854775807)<!>

    val d = id(22)
    checkSubtype<Int>(d)
@@ -24,7 +24,7 @@ fun test() {

    val f: Byte = either(1, 2)

-    val g: Byte = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>either<!>(1, 300)
+    val g: Byte = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>either(1, 300)<!>

    other(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>11<!>)

@@ -4,6 +4,6 @@ interface Foo

 fun test() {
    var nullable: Foo? = null
-    val foo: Collection<Foo> = java.util.Collections.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>singleton<!>(nullable)
+    val foo: Collection<Foo> = java.util.Collections.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>singleton(nullable)<!>
    val foo1: Collection<Foo> = java.util.Collections.singleton(nullable!!)
 }
@@ -19,7 +19,7 @@ val y4: B<Int> = B<Int>("")

 val y5: B<String> = <!NONE_APPLICABLE!>B<!><String>(1)
 val y6: B<String> = <!OVERLOAD_RESOLUTION_AMBIGUITY!>B<!><String>("") // TODO: doesn't work here but ok on y8
-val y7: B<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>B<!>(1)
+val y7: B<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>B(1)<!>
 val y8: B<String> = B("")

 val y9 = B(1)
@@ -28,7 +28,7 @@ fun test(a: A, b: B, c: C) {
        val k = three(a, b, c)
        checkSubtype<A>(k)
        checkSubtype<B>(<!TYPE_MISMATCH!>k<!>)
-        val l: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>three<!>(a, b, c)
+        val l: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>three(a, b, c)<!>
        
        use(d, e, f, g, h, k, l)
    }