FIR: Adjust test data after introduction of INFERENCE_NO_INFORMATION_FOR_PARAMETER

See previous commits for details
2021-05-26 12:36:15 +03:00
parent c420957eac
commit 0aca3a3737
160 changed files with 363 additions and 348 deletions
@@ -14,7 +14,7 @@ interface TestInterface<R> {
 }

 fun test() {
-    val ret = combined({ }) {
-        emit(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
+    val ret = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>combined<!>({ }) {
+        emit(1)
    }
 }
@@ -80,7 +80,7 @@ fun poll05(): Flow<String> {

 fun poll06(): Flow<String> {
    return flow {
-        val inv = select(foo7(), ::Foo7)
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(foo7(), ::Foo7)
        inv
    }
 }
@@ -479,21 +479,21 @@ fun poll85(): Flow<String> {

 fun poll86(): Flow<String> {
    return flow {
-        val inv = <!NEW_INFERENCE_ERROR!>::Foo7 in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!><!>
+        val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
        inv
    }
 }

 fun poll87(): Flow<String> {
    return flow {
-        val inv = ::Foo7 in setOf(foo7())
+        val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> setOf(foo7())
        inv
    }
 }

 fun poll88(): Flow<String> {
    return flow {
-        val inv = foo7() in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!>
+        val inv = foo7() in <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
        inv
    }
 }
@@ -81,7 +81,7 @@ fun poll05(): Flow<String> {

 fun poll06(): Flow<String> {
    return flow {
-        val inv = select(foo7(), ::Foo7)
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(foo7(), ::Foo7)
        inv
    }
 }
@@ -480,21 +480,21 @@ fun poll85(): Flow<String> {

 fun poll86(): Flow<String> {
    return flow {
-        val inv = <!NEW_INFERENCE_ERROR!>::Foo7 in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!><!>
+        val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
        inv
    }
 }

 fun poll87(): Flow<String> {
    return flow {
-        val inv = ::Foo7 in setOf(foo7())
+        val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> setOf(foo7())
        inv
    }
 }

 fun poll88(): Flow<String> {
    return flow {
-        val inv = foo7() in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!>
+        val inv = foo7() in <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
        inv
    }
 }
@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_PARAMETER
+
+class Foo<K>
+
+fun <T> getFoo(value: T) = null as Foo<out Foo<T>>
+fun <R> takeLambda(block: () -> R) {}
+
+fun main(x: Int) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeLambda<!> {
+        getFoo(x)
+    }
+}
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_PARAMETER

 class Foo<K>
@@ -10,4 +9,4 @@ fun main(x: Int) {
    takeLambda {
        getFoo(x)
    }
-}
+}
@@ -13,6 +13,6 @@ fun implicitCoercion() {

    val c = l@{
        // Error: block doesn't have an expected type, so call can't be inferred!
-        return@l materialize()
+        return@l <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
    }
 }
@@ -53,7 +53,7 @@ fun testParameter() {
    takeFnToParameter { Unit }
    takeFnToParameter { <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!> }
    takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
-    takeFnToParameter {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> {
        if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
    }
    takeFnToParameter(fun() = Unit)
@@ -57,7 +57,7 @@ fun test7(cls: Cls) {
 }

 fun test8(cls: Cls) {
-    id(
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(
        wrapIn(cls)
    )
 }
@@ -78,11 +78,11 @@ fun main() {

    // Interdependent lambdas by input-output types aren't supported
    takeInterdependentLambdas({}, {})
-    takeInterdependentLambdas({ it }, { <!ARGUMENT_TYPE_MISMATCH!>10<!> })
-    takeInterdependentLambdas({ <!ARGUMENT_TYPE_MISMATCH!>10<!> }, { it })
-    takeInterdependentLambdas({ <!ARGUMENT_TYPE_MISMATCH!>10<!> }, { x -> x })
-    takeInterdependentLambdas({ x -> <!ARGUMENT_TYPE_MISMATCH!>10<!> }, { it })
-    takeInterdependentLambdas({ it }, { x -> <!ARGUMENT_TYPE_MISMATCH!>10<!> })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ it }, { 10 })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ 10 }, { it })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ 10 }, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 }, { it })
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeInterdependentLambdas<!>({ it }, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> 10 })

    // Dependent lambdas by input-output types
    takeDependentLambdas({ <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>it<!> }, { it })
@@ -1,13 +1,13 @@
 // !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER -UNUSED_VARIABLE

-fun <T> select(vararg x: T) = x[0]
+fun <T> select(vararg x: <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>T<!>) = x[0]
 fun <K> id(x: K) = x

 fun main() {
    val x1 = select<Any?>(id { x, y -> }, { x: Int, y -> })
-    val x2 = <!NEW_INFERENCE_ERROR!>select(id { x, y -> }, { x: Int, y -> })<!>
+    val x2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(id { x, y -> }, { x: Int, y -> })

-    val x3 = <!NEW_INFERENCE_ERROR!>select(id(fun (x, y) {}), fun (x: Int, y) {})<!>
+    val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(id(fun (x, y) {}), fun (x: Int, y) {})

    val x4 = select<Any?>((fun (x, y) {}), fun (x: Int, y) {})
    val x5 = select<Any?>(id(fun (x, y) {}), fun (x: Int, y) {})
@@ -10,6 +10,6 @@ fun <R> choose3(c: Inv<Inv<R>>) {}

 fun f(o: Out<Out<*>>, i: In<In<*>>, inv: Inv<Inv<*>>) {
    choose1(o)
-    choose2(i)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>choose2<!>(i)
    choose3(<!ARGUMENT_TYPE_MISMATCH!>inv<!>)
 }
@@ -114,8 +114,8 @@ fun <L> main(x: L?, y: L) {
        foo16(y, Bar())
    }

-    Bar().foo18(x)
-    Bar().foo18(y)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().foo18(x)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().foo18(y)

    foo21(x, Foo(Foo(OutBar())))
    foo21(y, Foo(Foo(OutBar())))
@@ -164,11 +164,11 @@ class Main<L>(x: L?, y: L) {
    val x170 = foo17(x)
    val x171 = foo17(y)

-    val x180 = Bar().<!UNRESOLVED_REFERENCE!>foo18<!>(x)
-    val x181 = Bar().<!UNRESOLVED_REFERENCE!>foo18<!>(y)
+    val x180 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo18<!>(x)
+    val x181 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo18<!>(y)

-    val x200: L = Bar().<!UNRESOLVED_REFERENCE!>foo19<!>()
-    val x201: L = Bar().<!UNRESOLVED_REFERENCE!>foo19<!>()
+    val x200: L = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo19<!>()
+    val x201: L = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>().<!UNRESOLVED_REFERENCE!>foo19<!>()

    val x210 = foo21(x)
    val x211 = foo21(y)
@@ -262,8 +262,8 @@ class Main<L>(x: L?, y: L) {
    val x471 = foo47(y)

    fun <R> takeLambda(block: () -> R): R = materialize()
-    val x480 = <!NEW_INFERENCE_ERROR!>takeLambda { foo48 { <!ARGUMENT_TYPE_MISMATCH!>x<!> } }<!>
-    val x481 = <!NEW_INFERENCE_ERROR!>takeLambda { foo48 { <!ARGUMENT_TYPE_MISMATCH!>y<!> } }<!>
+    val x480 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeLambda<!> { foo48 { <!ARGUMENT_TYPE_MISMATCH!>x<!> } }
+    val x481 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeLambda<!> { foo48 { <!ARGUMENT_TYPE_MISMATCH!>y<!> } }
    val x482 = takeLambda { foo48 { null } }
 }

@@ -20,7 +20,7 @@ public class Foo {
 // FILE: test.kt

 fun test(e: <!UNRESOLVED_REFERENCE!>ErrorType<!>) {
-    Foo.foo {
+    Foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
        Sam.Result.create(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
    }
-}
+}
@@ -8,5 +8,5 @@ fun <T: Inv2<T>> foo(klass: Inv<T>): String? = null
 fun <X> bar(): Inv<X> = null!!

 fun test() {
-    <!NEW_INFERENCE_ERROR!>foo(bar())<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bar())
 }
@@ -1,4 +1,4 @@
 inline operator fun <reified T> Int.invoke() = this

-val a2 = 1()
-val a3 = 1.invoke()
+val a2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>1()<!>
+val a3 = 1.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>invoke<!>()
@@ -6,7 +6,7 @@ fun <T> foo() = foo() as T

 fun <T> foo2(): T = TODO()

-val test = foo2().plus("") <!USELESS_CAST!>as String<!>
+val test = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().plus("") <!USELESS_CAST!>as String<!>

 fun <T> T.bar() = this
 val barTest = "".bar() as Number
@@ -8,12 +8,11 @@ class A {

 fun <V> id(value: V) = value

-val asA = foo().<!UNRESOLVED_REFERENCE!>fooA<!>() as A
+val asA = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!UNRESOLVED_REFERENCE!>fooA<!>() as A

-val receiverParenthesized = (foo()).<!UNRESOLVED_REFERENCE!>fooA<!>() as A
-val no2A = A().fooA().<!UNRESOLVED_REFERENCE!>fooA<!>() as A
-
-val correct1 = A().fooA() as A
-val correct2 = foo<A>().fooA() as A
-val correct3 = A().fooA<A>().fooA() as A
+val receiverParenthesized = (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!UNRESOLVED_REFERENCE!>fooA<!>() as A
+val no2A = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!UNRESOLVED_REFERENCE!>fooA<!>() as A

+val correct1 = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>() as A
+val correct2 = foo<A>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>() as A
+val correct3 = A().fooA<A>().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>() as A
@@ -4,17 +4,17 @@ fun <T> foo(): T = TODO()

 fun <V> id(value: V) = value

-val asString = foo() as String
+val asString = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String

-val viaId = id(foo()) as String
+val viaId = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(foo()) as String

-val insideId = id(foo() as String)
+val insideId = id(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String)

-val asList = foo() as List<String>
+val asList = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as List<String>

-val asStarList = foo() as List<*>
+val asStarList = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as List<*>

-val safeAs = foo() as? String
+val safeAs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as? String

-val fromIs = <!USELESS_IS_CHECK!>foo() is String<!>
-val fromNoIs = <!USELESS_IS_CHECK!>foo() !is String<!>
+val fromIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is String
+val fromNoIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() !is String
@@ -11,7 +11,6 @@ class A {
    }
 }

-val x = A().foo() as String
-val y = A.foo2() as String
-val z = pp.A.foo2() as String
-
+val x = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String
+val y = A.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>() as String
+val z = pp.A.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>() as String
@@ -8,15 +8,15 @@ fun <T> foo(): T = TODO()

 fun <V> id(value: V) = value

-val par1 = (foo()) as String
-val par2 = ((foo())) as String
+val par1 = (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
+val par2 = ((<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>())) as String

-val par3 = (dd@ (foo())) as String
+val par3 = (dd@ (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>())) as String

-val par4 = ( @bar() (foo())) as String
+val par4 = ( @bar() (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>())) as String

 object X {
    fun <T> foo(): T = TODO()
 }

-val par5 = ( @bar() X.foo()) as String
+val par5 = ( @bar() X.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
@@ -5,13 +5,13 @@ class X<S> {
 }

 fun test(x: X<Number>) {
-    val y = x.foo() as Int
+    val y = x.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as Int
 }

 fun <S, D: S> g() {
    fun <T : S> foo(): T = TODO()

-    val y = foo() as Int
+    val y = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as Int

-    val y2 = foo() as D
+    val y2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as D
 }
@@ -25,35 +25,35 @@ class X : View()
 class Y<T> : View()

 val xExplicit: X = Test().findViewById(0)
-val xCast = Test().findViewById(0) as X
+val xCast = Test().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X

 val xCastExplicitType = Test().findViewById<X>(0) as X
 val xSafeCastExplicitType = Test().findViewById<X>(0) <!USELESS_CAST!>as? X<!>

 val yExplicit: Y<String> = Test().findViewById(0)
-val yCast = Test().findViewById(0) as Y<String>
+val yCast = Test().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as Y<String>


 class TestChild : Test() {
    val xExplicit: X = findViewById(0)
-    val xCast = findViewById(0) as X
+    val xCast = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X

    val yExplicit: Y<String> = findViewById(0)
-    val yCast = findViewById(0) as Y<String>
+    val yCast = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as Y<String>
 }

 fun test(t: Test) {
    val xExplicit: X = t.findViewById(0)
-    val xCast = t.findViewById(0) as X
+    val xCast = t.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X

    val yExplicit: Y<String> = t.findViewById(0)
-    val yCast = t.findViewById(0) as Y<String>
+    val yCast = t.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as Y<String>
 }

 fun test2(t: Test?) {
-    val xSafeCallSafeCast = t?.findViewById(0) as? X
+    val xSafeCallSafeCast = t?.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as? X
    val xSafeCallSafeCastExplicitType = t?.findViewById<X>(0) <!USELESS_CAST!>as? X<!>

-    val xSafeCallCast = t?.findViewById(0) as X
+    val xSafeCallCast = t?.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>findViewById<!>(0) as X
    val xSafeCallCastExplicitType = t<!UNNECESSARY_SAFE_CALL!>?.<!>findViewById<X>(0) as X
 }
@@ -12,5 +12,5 @@ fun test() {
    val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
    checkSubtype<Int>(q)

-    foo({}, emptyList())
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, emptyList())
 }
@@ -5,5 +5,5 @@ fun <K> select(): K = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>run { }<!>

 fun test() {
    val x: Int = select()
-    val t = select()
+    val t = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
 }
@@ -8,9 +8,9 @@ inline fun <reified T> foo(): T {
 }

 fun test() {
-    val fooCall = foo() as String // T in foo should be inferred to String
+    val fooCall = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as String // T in foo should be inferred to String
    fooCall checkType { _<String>() }

-    val safeFooCall = foo() as? String
+    val safeFooCall = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() as? String
    safeFooCall checkType { _<String?>() }
-}
+}
@@ -86,12 +86,12 @@ fun <T : Foo, R: Number, D: Int> main() {
    // with LHS and conflicting projection
    bar2<T>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
    bar2<Foo>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
-    bar2(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar2<!>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)

    // with LHS and Any? expected type
    bar3<T>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
    bar3<Foo>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
-    bar3(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar3<!>(Foo::<!OVERLOAD_RESOLUTION_AMBIGUITY!>resolve<!>)

    // with LHS and `Function` expected type
    bar4<T>(Foo::resolve) // ERROR before the fix in NI
@@ -8,6 +8,6 @@ class Foo<K> {
 }

 class Bar {
-    val bar = foo {}
+    val bar = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {}
    val baz = foo<Int> {}
-}
+}
@@ -3,11 +3,11 @@
 fun <T, R : Any> foo(body: (R?) -> T): T = fail()

 fun test1() {
-    foo {
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+        true
    }
-    foo { x ->
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        true
    }
 }

@@ -15,33 +15,33 @@ fun test1() {
 fun <T, R> bar(body: (R) -> T): T = fail()

 fun test2() {
-    bar {
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
+        true
    }
-    bar { x ->
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        true
    }
 }

 fun <T, R> baz(body: (List<R>) -> T): T = fail()

 fun test3() {
-    baz {
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
+        true
    }
-    baz { x ->
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { x ->
+        true
    }
 }

 fun <T, R : Any> brr(body: (List<R?>) -> T): T = fail()

 fun test4() {
-    brr {
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
+        true
    }
-    brr { x ->
-        <!ARGUMENT_TYPE_MISMATCH!>true<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { x ->
+        true
    }
 }

@@ -13,7 +13,7 @@ fun <T> id(t: T): T = t
 infix fun <T> Z.foo(a: A<T>): A<T> = a

 fun test(z: Z) {
-    z foo newA()
+    z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> newA()
    val a: A<Int> = id(z foo newA())
    val b: A<Int> = id(z.foo(newA()))
    use(a, b)
@@ -23,7 +23,7 @@ fun test(z: Z) {
 operator fun <T> Z.plus(a: A<T>): A<T> = a

 fun test1(z: Z) {
-    <!NEW_INFERENCE_ERROR!>id(z + newA())<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(z + newA())
    val a: A<Z> = z + newA()
    val b: A<Z> = z.plus(newA())
    val c: A<Z> = id(z + newA())
@@ -35,7 +35,7 @@ fun test1(z: Z) {
 operator fun <T> Z.compareTo(a: A<T>): Int { use(a); return 1 }

 fun test2(z: Z) {
-    val a: Boolean = id(z < newA())
+    val a: Boolean = id(z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><<!> newA())
    val b: Boolean = id(z < newA<Z>())
    use(a, b)
 }
@@ -44,18 +44,18 @@ fun test2(z: Z) {
 fun Z.equals(any: Any): Int { use(any); return 1 }

 fun test3(z: Z) {
-    z == newA()
+    z == <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
    z == newA<Z>()
-    id(z == newA())
+    id(z == <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    id(z == newA<Z>())

-    id(z === newA())
+    id(z === <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    id(z === newA<Z>())
 }

 //'in' operation
 fun test4(collection: Collection<A<*>>) {
-    id(newA() in collection)
+    id(newA() <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> collection)
    id(newA<Int>() in collection)
 }

@@ -63,7 +63,7 @@ fun test4(collection: Collection<A<*>>) {
 fun <T> toBeOrNot(): Boolean = throw Exception()

 fun test5() {
-    if (toBeOrNot() && toBeOrNot()) {}
+    if (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>() && <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>()) {}
    if (toBeOrNot<Int>() && toBeOrNot<Int>()) {}
 }

@@ -19,7 +19,7 @@ fun testAnyCall() {
 }

 fun testParam() {
-    callParam {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
        param -> param
    }
 }
@@ -7,5 +7,5 @@ import java.util.*
 fun <T> foo (f: () -> List<T>): T = null as T

 fun main() {
-    val x = foo { Collections.emptyList() }
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { Collections.emptyList() }
 }
@@ -14,5 +14,5 @@ fun test1() {
 }

 fun test2() {
-    ::foo.call({ x -> println(x::class) })
+    ::foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>call<!>({ x -> println(x::class) })
 }
@@ -5,7 +5,7 @@
 class Inv<I>
 fun <T> materialize(): Inv<T> = TODO()
 fun <K> id(arg: K) = arg
-fun <S> select(vararg args: S): S = TODO()
+fun <S> select(vararg args: <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>S<!>): S = TODO()

 fun test1(b: Boolean?) {
    val v = when(b) {
@@ -17,20 +17,20 @@ fun test1(b: Boolean?) {
 }

 fun test2() {
-    <!NEW_INFERENCE_ERROR!>select(
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(
        materialize()
-    )<!>
+    )
    select(materialize(), materialize<String>())
    select(materialize(), null, Inv<String>())
    <!NEW_INFERENCE_ERROR!>select(
        materialize(),
        null
    )<!>
-    <!NEW_INFERENCE_ERROR!>select(
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(
        materialize(),
        materialize()
-    )<!>
-    select(
+    )
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(
        materialize(),
        materialize(),
        null
@@ -5,7 +5,7 @@ fun <I> id(arg: I): I = arg
 fun <S> select(vararg args: S): S = TODO()

 fun test() {
-    id(
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(
        make()
    )

@@ -6,7 +6,7 @@ fun <T> g (f: () -> List<T>) : T {}

 fun test() {
    //here possibly can be a cycle on constraints
-    val x = g { Collections.emptyList() }
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>g<!> { Collections.emptyList() }

    val y = g<Int> { Collections.emptyList() }
    val z : List<Int> = g { Collections.emptyList() }
@@ -5,7 +5,7 @@ package n
 import checkSubtype

 fun main() {
-    val a = array(array())
+    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(array())
    val a0 : Array<Array<Int>> = array(array())
    val a1 = array(array<Int>())
    checkSubtype<Array<Array<Int>>>(a1)
@@ -15,4 +15,4 @@ fun main() {

 //from library
@Suppress("UNCHECKED_CAST")
-fun <T> array(vararg t : T) : Array<T> = t as Array<T>
+fun <T> array(vararg t : <!CANNOT_INFER_PARAMETER_TYPE!>T<!>) : Array<T> = t as Array<T>
@@ -3,7 +3,7 @@ fun <K> id(arg: K): K = arg
 fun <M> materialize(): M = TODO()

 fun test(b: Boolean) {
-    id(if (b) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(if (b) {
        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
    } else {
        id(
@@ -4,6 +4,5 @@ fun <T, R, S> foo(block: (T)-> R, second: (T)-> S) = block

 fun main() {
    val fff = { x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
-    foo(<!ARGUMENT_TYPE_MISMATCH!>fff<!>, { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1 })
+    foo(<!ARGUMENT_TYPE_MISMATCH!>fff<!>, { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x + 1 })
 }
-
@@ -10,7 +10,7 @@ fun test() {
    foo <!ARGUMENT_TYPE_MISMATCH!>{ x -> x}<!>
    foo <!ARGUMENT_TYPE_MISMATCH!>{ x: Int -> x}<!>

-    bar { it <!UNRESOLVED_REFERENCE!>+<!> 1 }
-    bar { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1}
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { it + 1 }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> x + 1}
    bar { x: Int -> x + 1}
 }
@@ -3,9 +3,9 @@ package aa
 fun <T, R> foo(block: (T)-> R) = block

 fun test1() {
-    foo {
-        x ->  // here we have 'cannot infer parameter type' error
-        <!ARGUMENT_TYPE_MISMATCH!>43<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->  // here we have 'cannot infer parameter type' error
+        43
    }
 }

@@ -7,6 +7,6 @@ fun test() {
    id2(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
    id2(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>, <!ARGUMENT_TYPE_MISMATCH!>42<!>)

-    ret("foo")
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>ret<!>("foo")
    ret(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
 }
@@ -3,6 +3,6 @@ class X
 operator fun <T> X.iterator(): Iterable<T> = TODO()

 fun test() {
-    for (i in <!HAS_NEXT_MISSING, NEXT_MISSING!>X()<!>) {
+    for (i in X()) {
    }
 }
@@ -284,7 +284,7 @@ fun poll82() {
 }

 fun poll83() {
-    val inv = <!NEW_INFERENCE_ERROR!>::bar4 in <!NEW_INFERENCE_ERROR!>setOf(::foo4)<!><!>
+    val inv = ::bar4 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::foo4)
    inv
 }

@@ -299,16 +299,16 @@ fun poll85() {
 }

 fun poll86() {
-    val inv = <!NEW_INFERENCE_ERROR!>::Foo7 in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!><!>
+    val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
    inv
 }

 fun poll87() {
-    val inv = ::Foo7 in setOf(foo7())
+    val inv = ::Foo7 <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>in<!> setOf(foo7())
    inv
 }

 fun poll88() {
-    val inv = foo7() in <!NEW_INFERENCE_ERROR!>setOf(::Foo7)<!>
+    val inv = foo7() in <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>setOf<!>(::Foo7)
    inv
 }
@@ -5,7 +5,7 @@ interface A
 fun <T> emptyList(): List<T> = throw Exception()

 fun test1() {
-    emptyList()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 }

 //--------------
@@ -13,7 +13,7 @@ fun test1() {
 fun <T: A> emptyListOfA(): List<T> = throw Exception()

 fun test2() {
-    emptyListOfA()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyListOfA<!>()
 }

 //--------------
@@ -21,7 +21,7 @@ fun test2() {
 fun <T: A, R: T> emptyStrangeMap(): Map<T, R> = throw Exception()

 fun test3() {
-    emptyStrangeMap()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
 }

 //--------------
@@ -10,5 +10,5 @@ class Bar<U : I>(val x: Inv<Out<U>>)
 fun <T> materializeFoo(): Inv<T> = null as Inv<T>

 fun main() {
-    Bar(materializeFoo())
-}
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Bar<!>(materializeFoo())
+}