FIR: Adjust test data after introduction of INFERENCE_NO_INFORMATION_FOR_PARAMETER

See previous commits for details

compiler/testData/diagnostics/testsWithStdLib/builderInference/inferCoroutineTypeInOldVersion.fir.kt

@@ -12,18 +12,18 @@ fun <S> Builder<S>.extensionAdd(s: S) {}
 
 suspend fun <S> Builder<S>.safeExtensionAdd(s: S) {}
 
-val member = build {
-    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
+val member = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    add(42)
 }
 
-val memberWithoutAnn = wrongBuild {
-    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
+val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
+    add(42)
 }
 
-val extension = build {
-    extensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
+val extension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    extensionAdd("foo")
 }
 
-val safeExtension = build {
-    safeExtensionAdd(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
+val safeExtension = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
+    safeExtensionAdd("foo")
 }

compiler/testData/diagnostics/testsWithStdLib/builderInference/resolveUsualCallWithBuilderInferenceWithRestrictions.fir.kt

@@ -24,8 +24,8 @@ val member = build {
     add(42)
 }
 
-val memberWithoutAnn = wrongBuild {
-    add(<!ARGUMENT_TYPE_MISMATCH!>42<!>)
+val memberWithoutAnn = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
+    add(42)
 }
 
 val extension = build {

compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/callableReferenceOnUnresolvedLHS.fir.kt

@@ -8,6 +8,6 @@ class Scope<InterfaceT, ImplementationT : InterfaceT>(private val implClass: <!U
         val hm = c.asSequence()
             .<!INAPPLICABLE_CANDIDATE!>filter<!>(implClass::<!UNRESOLVED_REFERENCE!>isInstance<!>)
             .<!INAPPLICABLE_CANDIDATE!>map<!>(implClass::<!UNRESOLVED_REFERENCE!>cast<!>)
-            .toSet()
+            .<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toSet<!>()
     }
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt

@@ -7,26 +7,26 @@ class Controller<T> {
 
 fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 
-val test1 = generate {
-    apply {
-        yield(<!ARGUMENT_TYPE_MISMATCH!>4<!>)
+val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!> {
+        yield(4)
     }
 }
 
-val test2 = generate {
-    yield(<!ARGUMENT_TYPE_MISMATCH!>B<!>)
-    apply {
-        yield(<!ARGUMENT_TYPE_MISMATCH!>C<!>)
+val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield(B)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!> {
+        yield(C)
     }
 }
 
-val test3 = generate {
-    this.let {
-        yield(<!ARGUMENT_TYPE_MISMATCH!>B<!>)
+val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    this.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> {
+        yield(B)
     }
 
-    apply {
-        yield(<!ARGUMENT_TYPE_MISMATCH!>C<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!> {
+        yield(C)
     }
 }
 

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.fir.kt

@@ -28,7 +28,7 @@ val test1 = generate {
     baseExtension()
 }
 
-val test2 = generate {
+val test2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
     baseExtension()
 }
 

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.fir.kt

@@ -11,7 +11,7 @@ fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 
 suspend fun Base.baseExtension() {}
 
-val test1 = generate {
-    yield(<!ARGUMENT_TYPE_MISMATCH!>"foo"<!>)
+val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield("foo")
     baseExtension()
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.fir.kt

@@ -13,7 +13,7 @@ fun test_1() {
 }
 
 fun test_2() {
-    sequence {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>sequence<!> {
         yield(materialize())
     }
 }
@@ -21,7 +21,7 @@ fun test_2() {
 fun test_3() {
     sequence {
         yield(materialize<Int>())
-        materialize()
+        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
 

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41164.fir.kt

@@ -16,10 +16,10 @@ fun MyProducerScope<*>.myAwaitClose(block: () -> Unit = {}) {}
 fun <T> myEmptyFlow(): MyFlow<T> = null!!
 
 fun test(): MyFlow<Int> {
-    return <!TYPE_MISMATCH!>select(
-        <!DEBUG_INFO_EXPRESSION_TYPE("MyFlow<kotlin.Any?>")!>myCallbackFlow <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<MyProducerScope<kotlin.Any?>, kotlin.Unit>")!>{
+    return select(
+        <!DEBUG_INFO_EXPRESSION_TYPE("MyFlow<kotlin.Int>")!>myCallbackFlow <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<MyProducerScope<kotlin.Int>, kotlin.Unit>")!>{
             myAwaitClose {}
         }<!><!>,
         myEmptyFlow()
-    )<!>
+    )
 }

compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt

@@ -14,5 +14,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() ?: <!TYPE_MISMATCH!>listOf()<!><!>
+    return c.getList() ?: <!TYPE_MISMATCH!>listOf()<!>
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.fir.kt

@@ -23,7 +23,7 @@ public class StaticOverrides {
 // FILE: test.kt
 
 fun test() {
-    StaticOverrides.A.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Boolean>() }
+    StaticOverrides.A.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Boolean>() }
     StaticOverrides.B.foo {} checkType { _<String>() }
-    StaticOverrides.C.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Boolean>() }
+    StaticOverrides.C.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Boolean>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.fir.kt

@@ -19,6 +19,6 @@ class Foo {
 
 // FILE: 1.kt
 fun test() {
-    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
+    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.fir.kt

@@ -20,6 +20,6 @@ class Foo {
 
 // FILE: 1.kt
 fun test() {
-    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
+    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.fir.kt

@@ -16,5 +16,5 @@ public class Foo {
 
 // FILE: 1.kt
 fun bar() {
-    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>test<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>test<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.fir.kt

@@ -17,5 +17,5 @@ public class Foo {
 
 // FILE: 1.kt
 fun bar() {
-    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>test<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    Foo().<!OVERLOAD_RESOLUTION_AMBIGUITY!>test<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
 }

compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors.fir.kt

@@ -0,0 +1,8 @@
+// FILE: test.kt
+typealias RunnableT = java.lang.Runnable
+typealias ComparatorT<T> = java.util.Comparator<T>
+typealias ComparatorStrT = ComparatorT<String>
+
+val test1 = RunnableT { }
+val test2 = ComparatorT<String> { s1, s2 -> s1.compareTo(s2) }
+val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>ComparatorStrT<!> { <!CANNOT_INFER_PARAMETER_TYPE!>s1<!>, <!CANNOT_INFER_PARAMETER_TYPE!>s2<!> -> s1.compareTo(s2) }

compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: test.kt
 typealias RunnableT = java.lang.Runnable
 typealias ComparatorT<T> = java.util.Comparator<T>

compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors2.fir.kt

@@ -22,6 +22,6 @@ typealias C2<T> = JHost.Consumer2<T, T>
 
 val test1 = R { }
 val test2 = C<String> { s -> println(s.length) }
-val test3 = CStr { s -> <!OVERLOAD_RESOLUTION_AMBIGUITY!>println<!>(s.<!UNRESOLVED_REFERENCE!>length<!>) }
-val test4 = CStrList { ss -> for (s in <!ITERATOR_AMBIGUITY!>ss<!>) { <!OVERLOAD_RESOLUTION_AMBIGUITY!>println<!>(s.<!UNRESOLVED_REFERENCE!>length<!>) } }
-val test5 = <!INAPPLICABLE_CANDIDATE!>C2<!><Int> { a, b -> val x: Int = a <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> b; println(x)}
+val test3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>CStr<!> { <!CANNOT_INFER_PARAMETER_TYPE!>s<!> -> <!OVERLOAD_RESOLUTION_AMBIGUITY!>println<!>(s.<!UNRESOLVED_REFERENCE!>length<!>) }
+val test4 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>CStrList<!> { <!CANNOT_INFER_PARAMETER_TYPE!>ss<!> -> for (s in <!ITERATOR_AMBIGUITY!>ss<!>) { <!OVERLOAD_RESOLUTION_AMBIGUITY!>println<!>(s.<!UNRESOLVED_REFERENCE!>length<!>) } }
+val test5 = <!INAPPLICABLE_CANDIDATE!>C2<!><<!CANNOT_INFER_PARAMETER_TYPE!>Int<!>> { <!CANNOT_INFER_PARAMETER_TYPE!>a<!>, <!CANNOT_INFER_PARAMETER_TYPE!>b<!> -> val x: Int = a <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> b; println(x)}

compiler/testData/diagnostics/testsWithStdLib/when/kt10807.fir.kt

@@ -5,13 +5,13 @@ import kotlin.comparisons.nullsLast
 class Foo(val a: String, val b: Int)
 
 fun getComp(): Comparator<Foo?> =
-        <!RETURN_TYPE_MISMATCH!>when {
-            else -> nullsLast(compareBy({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> }))
-        }<!>
+        when {
+            else -> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>nullsLast<!>(compareBy({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> }))
+        }
 
 fun getCompInverted(): Comparator<Foo?> =
-        <!TYPE_MISMATCH!>nullsLast(
+        nullsLast(
                 when {
-                    else -> compareBy({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> })
+                    else -> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>compareBy<!>({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> })
                 }
-        )<!>
+        )