[FIR] Don't report ARGUMENT_TYPE_MISMATCH on error types

compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.fir.kt

@@ -1,9 +0,0 @@
-// !CHECK_TYPE
-
-interface Tr
-interface G<T>
-
-fun test(tr: Tr?) {
-    val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G<!>
-    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
-}

compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 interface Tr

compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.fir.kt

@@ -1,9 +0,0 @@
-// !CHECK_TYPE
-
-interface Tr
-interface G<T>
-
-fun test(tr: Tr) {
-    val v = tr as <!NO_TYPE_ARGUMENTS_ON_RHS!>G<!>
-    checkSubtype<G<*>>(<!ARGUMENT_TYPE_MISMATCH!>v<!>)
-}

compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 interface Tr

compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.fir.kt

@@ -3,7 +3,7 @@
 import kotlin.reflect.KProperty
 
 var a: Int by A()
-var a1 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A()<!>
+var a1 by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A()<!>
 
 var b: Int by B()
 

compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt

@@ -4,7 +4,7 @@
 import kotlin.reflect.KProperty
 
 class B {
-    val c by Delegate(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>ag<!>)
+    val c by <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)
 }
 
 class Delegate<T: Any>(val init: T) {

compiler/testData/diagnostics/tests/extensions/contextReceivers/conflictingWithDifferentOrder.fir.kt

@@ -12,7 +12,7 @@ fun f(): Unit<!> = TODO()
 fun test(a: A, b: B) {
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>(a) {
         with(b) {
-            <!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>()<!>
+            <!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>()
         }
     }
 }

compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.fir.kt

@@ -9,8 +9,8 @@ class Foo {
 }
 
 fun main() {
-    with("", {
-        <!ARGUMENT_TYPE_MISMATCH!>Foo.<!UNRESOLVED_REFERENCE!>findByName<!>("")<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!>("", {
+        Foo.<!UNRESOLVED_REFERENCE!>findByName<!>("")
     })
     with(Foo) {
         findByName("")

compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.fir.kt

@@ -51,7 +51,7 @@ fun testUnit() {
 fun testParameter() {
     takeFnToParameter {  }
     takeFnToParameter { Unit }
-    takeFnToParameter { <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!> }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
     takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> {
         if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
@@ -65,7 +65,7 @@ fun testParameter() {
     takeFnToParameter(fun(): Unit { return Unit })
     takeFnToParameter(fun() { if (true) return })
     takeFnToParameter(fun() { if (true) return Unit })
-    takeFnToParameter(fun() = <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!>(fun() = <!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/completeInferenceIfManyFailed.fir.kt

@@ -14,5 +14,5 @@ fun <T: Any> joinT(x: Comparable<*>, y: T): T? {
 
 fun test() {
     val x2 = <!NONE_APPLICABLE!>joinT<!>(Unit, "2")
-    checkSubtype<String?>(<!ARGUMENT_TYPE_MISMATCH!>x2<!>)
+    checkSubtype<String?>(x2)
 }

compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt

@@ -20,6 +20,6 @@ public class Foo {
 
 fun test(e: <!UNRESOLVED_REFERENCE!>ErrorType<!>) {
     Foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
-        Sam.Result.create(<!ARGUMENT_TYPE_MISMATCH!>e<!>)
+        Sam.Result.create(e)
     }
 }

compiler/testData/diagnostics/tests/inference/emptyIntersectionTypes/kt52393.fir.kt

@@ -11,7 +11,7 @@ fun main() {
     val number: Int = 5 // doesn't work
 //    val number: Long = 5 // works
 
-    with (WrapperFunctions()) {
-        <!ARGUMENT_TYPE_MISMATCH!>wrapper <!NONE_APPLICABLE!>greaterEq<!> number<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>with<!> (WrapperFunctions()) {
+        wrapper <!NONE_APPLICABLE!>greaterEq<!> number
     }
-}
+}

compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.fir.kt

@@ -4,5 +4,5 @@ fun <T> foo(t: T, t1: T) {}
 
 fun test() {
     //no type inference error
-    foo(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>aaab<!>, <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>bbb<!>)
-}
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!UNRESOLVED_REFERENCE!>aaab<!>, <!UNRESOLVED_REFERENCE!>bbb<!>)
+}

compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.fir.kt

@@ -15,7 +15,7 @@ fun testAny() {
 
 fun testAnyCall() {
     callAny {
-        error -> <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>error<!>()<!>
+        error -> <!UNRESOLVED_REFERENCE!>error<!>()
     }
 }
 
@@ -26,8 +26,8 @@ fun testParam() {
 }
 
 fun testParamCall() {
-    callParam {
-        param -> <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>param<!>()<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
+        param -> <!UNRESOLVED_REFERENCE!>param<!>()
     }
 }
 

compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.fir.kt

@@ -37,7 +37,7 @@ fun testStarProjection() = BiParam(
     intersect(First, Second),
     makeStarProjection()
 )
-fun testErrorType() = BiParam(
+fun testErrorType() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>BiParam<!>(
     intersect(First, Second),
-    <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>
+    <!UNRESOLVED_REFERENCE!>unresolved<!>
 )

compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.fir.kt

@@ -12,7 +12,7 @@ fun insideJob1() = doTheJob1()
 suspend fun insideJob2() = doTheJob2()
 suspend fun insideJob3() = doTheJob3()
 
-fun doTheJob0() = simpleAsync0 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob0()<!> }
-fun doTheJob1() = simpleAsync1 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob1()<!> }
-suspend fun doTheJob2() = simpleAsync2 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NON_LOCAL_SUSPENSION_POINT!>insideJob2<!>()<!> }
-suspend fun doTheJob3() = simpleAsync3 { <!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob3()<!> }
+fun doTheJob0() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync0<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob0()<!> }
+fun doTheJob1() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync1<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob1()<!> }
+suspend fun doTheJob2() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync2<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NON_LOCAL_SUSPENSION_POINT!>insideJob2<!>()<!> }
+suspend fun doTheJob3() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>simpleAsync3<!> { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>insideJob3()<!> }

compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.fir.kt

@@ -3,7 +3,7 @@ fun foo() {
     fun bar1() = bar1()
 
     fun bar2() = 1 <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> bar2()
-    fun bar3() = id(<!ARGUMENT_TYPE_MISMATCH!>bar3()<!>)
+    fun bar3() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(bar3())
 }
 
 fun <T> id(x: T) = x

compiler/testData/diagnostics/tests/inference/regressions/kt2741.fir.kt

@@ -8,5 +8,5 @@ fun <T> _arrayList(vararg values: T) : List<T> = throw Exception()
 class _Pair<A>(val a: A)
 
 fun test() {
-    _arrayList(_Pair(1))._sortBy { it -> <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xxx<!> }
+    _arrayList(_Pair(1)).<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>_sortBy<!> { it -> <!UNRESOLVED_REFERENCE!>xxx<!> }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841.fir.kt

@@ -9,8 +9,8 @@ public inline fun <T: Closeable, R> T.use1(block: (T)-> R) : R {
 }
 
 fun main() {
-    C().use1 {
+    C().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use1<!> {
         w ->  // ERROR here
-        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
+        <!UNRESOLVED_REFERENCE!>x<!>
     }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.fir.kt

@@ -12,8 +12,8 @@ public inline fun <T: Closeable, R> T.use(block: (t: T)-> R) : R {
 }
 
 fun test() {
-    C().use {
+    C().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use<!> {
         it.close()
-        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
+        <!UNRESOLVED_REFERENCE!>x<!>
     }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.fir.kt

@@ -12,9 +12,9 @@ public inline fun <T: Closeable, R> use(t: T, block: T.(T)-> R) : R {
 }
 
 fun test() {
-    use(C()) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use<!>(C()) {
         this.close()
         it.close()
-        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xx<!>
+        <!UNRESOLVED_REFERENCE!>xx<!>
     }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.fir.kt

@@ -12,8 +12,8 @@ public inline fun <T: Closeable, R> T.use(block: T.()-> R) : R {
 }
 
 fun test() {
-    C().use {
+    C().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>use<!> {
         this.close()
-        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
+        <!UNRESOLVED_REFERENCE!>x<!>
     }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt36342.fir.kt

@@ -4,21 +4,21 @@ import java.lang.Exception
 fun <K> id(arg: K): K = arg
 
 fun test() {
-    id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)!!
+    id(<!UNRESOLVED_REFERENCE!>unresolved<!>)!!
     <!UNRESOLVED_REFERENCE!>unresolved<!>!!!!
     try {
-        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     } catch (e: Exception) {
-        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     }
 
     if (true)
-        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     else
-        id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
 
     when {
-        true -> id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
+        true -> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     }
-    id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>)
+    id(<!UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
 }

compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.fir.kt

@@ -4,7 +4,7 @@ fun <M> materialize(): M = TODO()
 
 fun test(b: Boolean) {
     <!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<!>)
+        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     } else {
         id(
             materialize()

compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt

@@ -6,7 +6,7 @@ fun <T, R> foo(a: A<T, R>) = a
 fun <T, R> bar(f: (T) -> R) = f
 
 fun test() {
-    foo <!ARGUMENT_TYPE_MISMATCH!>{ <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }<!>
+    foo <!ARGUMENT_TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
     foo <!ARGUMENT_TYPE_MISMATCH!>{ x -> x}<!>
     foo <!ARGUMENT_TYPE_MISMATCH!>{ x: Int -> x}<!>
 

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.fir.kt

@@ -9,8 +9,8 @@ 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
+    C().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { // no ambiguity here
         www ->
-        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xs<!>
+        <!UNRESOLVED_REFERENCE!>xs<!>
     }
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt

@@ -4,8 +4,8 @@ fun <K> id2(x: K, s: String): K = x
 fun <K> ret(s: String): K = TODO()
 
 fun test() {
-    id2(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
-    id2(<!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>unresolved<!>, <!ARGUMENT_TYPE_MISMATCH!>42<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id2<!>(<!UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
+    id2(<!UNRESOLVED_REFERENCE!>unresolved<!>, <!ARGUMENT_TYPE_MISMATCH!>42<!>)
 
     <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>ret<!>("foo")
     ret(<!ARGUMENT_TYPE_MISMATCH!>42<!>)

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt

@@ -6,7 +6,7 @@ object Outer {
                 get() = 0
 
             override fun get(index: Int): Char {
-                checkSubtype<CharSequence>(<!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!>)
+                checkSubtype<CharSequence>(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!>)
                 return ' '
             }
 

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt

@@ -9,8 +9,8 @@ class A {
     val a get() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>
     val b get() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>
 
-    val z1 get() = id(<!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
-    val z2 get() = l(<!ARGUMENT_TYPE_MISMATCH, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)
+    val z1 get() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
+    val z2 get() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>l<!>(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)
 
     val u get() = <!UNRESOLVED_REFERENCE!>field<!>
 }

compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt

@@ -83,7 +83,7 @@ fun test2() { // to extension lambda 1
     val i27a: E1 = <!INITIALIZER_TYPE_MISMATCH!>when (e) { E.VALUE ->  { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } }<!> // oi+ ni+
 
     val w28 = W2 <!ARGUMENT_TYPE_MISMATCH!>{ i: Int, <!CANNOT_INFER_PARAMETER_TYPE!>s<!> -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> }<!> // oi- ni-
-    val i28: E1 = id { i: Int, <!CANNOT_INFER_PARAMETER_TYPE!>s<!> -> <!ARGUMENT_TYPE_MISMATCH!>i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!><!> } // oi- ni-
+    val i28: E1 = id { i: Int, <!CANNOT_INFER_PARAMETER_TYPE!>s<!> -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
     val w29 = W2 <!ARGUMENT_TYPE_MISMATCH!>{ i: Int, s: String -> i + s.length }<!> // oi- ni-
     val i29: E1 = id { i: Int, s: String -> i + s.length } // oi+ ni+