K2: Avoid losing diagnostics for synthetic calls

Some of the changed tests may duplicate other existing diagnostics,
but that should not be reason not to report them at all.

There might be another job to be done to avoid diagnostic duplications

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -5,8 +5,10 @@
 
 package org.jetbrains.kotlin.fir.resolve.transformers
 
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.fakeElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.FirSimpleFunctionBuilder
@@ -204,7 +206,7 @@ class FirSyntheticCallGenerator(
             )
         }
 
-        return FirNamedReferenceWithCandidate(null, name, candidate)
+        return FirNamedReferenceWithCandidate(callSite.source?.fakeElement(KtFakeSourceElementKind.SyntheticCall), name, candidate)
     }
 
     private fun generateCandidate(callInfo: CallInfo, function: FirSimpleFunction, context: ResolutionContext): Candidate {

compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt

@@ -251,6 +251,9 @@ sealed class KtFakeSourceElementKind(final override val shouldSkipErrorTypeRepor
 
     // for return type of value parameters in lambdas
     object ImplicitReturnTypeOfLambdaValueParameter : KtFakeSourceElementKind()
+
+    // Synthetic calls for if/when/try/etc.
+    object SyntheticCall : KtFakeSourceElementKind()
 }
 
 sealed class AbstractKtSourceElement {
@@ -503,4 +506,3 @@ inline fun LighterASTNode.toKtLightSourceElement(
     startOffset: Int = this.startOffset,
     endOffset: Int = this.endOffset
 ): KtLightSourceElement = KtLightSourceElement(this, startOffset, endOffset, tree, kind)
-

compiler/testData/diagnostics/tests/QualifiedExpressions.fir.kt

@@ -4,8 +4,8 @@ fun test(s: IntRange?) {
    val a: Int = <!INITIALIZER_TYPE_MISMATCH!>s?.start<!>
    val b: Int? = s?.start
    val c: Int = s?.start ?: -11
-   val d: Int = s?.start ?: "empty"
+   val d: Int = <!TYPE_MISMATCH!>s?.start ?: "empty"<!>
-   val e: String = s?.start ?: "empty"
+   val e: String = <!TYPE_MISMATCH!>s?.start ?: "empty"<!>
    val f: Int = s?.endInclusive ?: b ?: 1
    val g: Boolean? = e.startsWith("s")//?.length
 }

compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsOutsideOfAnnotations.fir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+
+fun takeArray(array: Array<String>) {}
+
+fun test() {
+    "foo bar".<!UNRESOLVED_REFERENCE!>split<!>(<!UNSUPPORTED!>[""]<!>)
+    <!UNRESOLVED_REFERENCE!>unresolved<!>(<!UNSUPPORTED!>[""]<!>)
+    takeArray(<!UNSUPPORTED!>[""]<!>)
+    val v = <!UNSUPPORTED!>[""]<!>
+    <!UNSUPPORTED!>[""]<!>
+    <!UNSUPPORTED!>[1, 2, 3]<!>.size
+}
+
+fun baz(arg: Array<Int> = <!UNSUPPORTED!>[]<!>) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (true) <!UNSUPPORTED!>["yes"]<!> else {<!UNSUPPORTED!>["no"]<!>}<!>
+}
+
+class Foo(
+    val v: Array<Int> = <!UNSUPPORTED!>[]<!>
+)

compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsOutsideOfAnnotations.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 
 fun takeArray(array: Array<String>) {}

compiler/testData/diagnostics/tests/collectionLiterals/kt34515.fir.kt

@@ -1,3 +1,3 @@
 fun main() {
-    <!UNSUPPORTED!>[]<!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>!!
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!UNSUPPORTED!>[]<!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>!!<!>
 }

compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.fir.kt

@@ -29,7 +29,7 @@ val testSafeCall4: String? = J.m[""]?.let { it.toString() }
 val testIf1: String = if (true) J.s else J.s
 val testIf2: String? = if (true) J.s else J.s
 
-val testIf3: String = <!INITIALIZER_TYPE_MISMATCH!>if (true) J.m[""] else J.m[""]<!>
+val testIf3: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>if (true) J.m[""] else J.m[""]<!>
 val testIf4: String? = if (true) J.m[""] else J.m[""]
 
 val testWhen1: String = when { else -> J.s }

compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.fir.kt

@@ -1,6 +1,6 @@
 
 fun test1() {
-    if (<!UNRESOLVED_REFERENCE!>rr<!>) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (<!UNRESOLVED_REFERENCE!>rr<!>) {
         if (<!UNRESOLVED_REFERENCE!>l<!>) {
             <!UNRESOLVED_REFERENCE!>a<!>.q()
         }
@@ -15,7 +15,7 @@ fun test1() {
         else {
             <!UNRESOLVED_REFERENCE!>a<!>.u()
         }
-    }
+    }<!>
 }
 
 fun test2(l: List<<!UNRESOLVED_REFERENCE!>AA<!>>) {

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt

@@ -136,7 +136,7 @@ fun poll16(flag: Boolean): Flow<String> {
 
 fun poll17(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { foo7() } else { ::Foo7 }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (flag) { foo7() } else { ::Foo7 }<!>
         inv
     }
 }
@@ -185,7 +185,7 @@ fun poll25(flag: Boolean): Flow<String> {
 
 fun poll26(flag: Boolean): Flow<String> {
     return flow {
-        val inv = when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }<!>
         inv
     }
 }
@@ -234,7 +234,7 @@ fun poll35(flag: Boolean): Flow<String> {
 
 fun poll36(flag: Boolean): Flow<String> {
     return flow {
-        val inv = when (flag) { true -> ::Foo7 false -> foo7() }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() }<!>
         inv
     }
 }
@@ -332,7 +332,7 @@ fun poll55(): Flow<String> {
 
 fun poll56(): Flow<String> {
     return flow {
-        val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }<!>
         inv
     }
 }
@@ -430,7 +430,7 @@ fun poll75(): Flow<String> {
 
 fun poll76(): Flow<String> {
     return flow {
-        val inv = ::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!><!>
         inv
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt

@@ -85,7 +85,7 @@ fun poll16(flag: Boolean): Flow<String> {
 
 fun poll17(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { foo7() } else { ::Foo7 }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (flag) { foo7() } else { ::Foo7 }<!>
         inv
     }
 }
@@ -183,7 +183,7 @@ fun poll55(): Flow<String> {
 
 fun poll56(): Flow<String> {
     return flow {
-        val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }<!>
         inv
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt

@@ -79,7 +79,7 @@ fun poll75(): Flow<String> {
 
 fun poll76(): Flow<String> {
     return flow {
-        val inv = ::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!><!>
         inv
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.fir.kt

@@ -80,7 +80,7 @@ fun poll75(): Flow<String> {
 
 fun poll76(): Flow<String> {
     return flow {
-        val inv = ::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!><!>
         inv
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt

@@ -138,7 +138,7 @@ fun poll16(flag: Boolean): Flow<String> {
 
 fun poll17(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { foo7() } else { ::Foo7 }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (flag) { foo7() } else { ::Foo7 }<!>
         inv
     }
 }
@@ -187,7 +187,7 @@ fun poll25(flag: Boolean): Flow<String> {
 
 fun poll26(flag: Boolean): Flow<String> {
     return flow {
-        val inv = when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }<!>
         inv
     }
 }
@@ -236,7 +236,7 @@ fun poll35(flag: Boolean): Flow<String> {
 
 fun poll36(flag: Boolean): Flow<String> {
     return flow {
-        val inv = when (flag) { true -> ::Foo7 false -> foo7() }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() }<!>
         inv
     }
 }
@@ -334,7 +334,7 @@ fun poll55(): Flow<String> {
 
 fun poll56(): Flow<String> {
     return flow {
-        val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }<!>
         inv
     }
 }
@@ -432,7 +432,7 @@ fun poll75(): Flow<String> {
 
 fun poll76(): Flow<String> {
     return flow {
-        val inv = ::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!><!>
         inv
     }
 }

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

@@ -8,9 +8,9 @@ fun main() {
     val x3: () -> String = if (true) {{ -> "this" }} else {{ -> "this" }}
     val x4: String.() -> String = if (true) {{ str: String -> "this" }} else {{ str: String -> "this" }}
     val x41: String.(String) -> String = if (true) {{ str: String, str2: String -> "this" }} else {{ str: String, str2: String -> "this" }}
-    val x42: String.(String) -> String = if (true) {{ str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!> -> "this" }} else {{ str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!> -> "this" }}
+    val x42: String.(String) -> String = if (true) {<!ARGUMENT_TYPE_MISMATCH!>{ str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!> -> "this" }<!>} else {<!ARGUMENT_TYPE_MISMATCH!>{ str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!> -> "this" }<!>}
-    val x5: String.() -> String = if (true) {{ <!CANNOT_INFER_PARAMETER_TYPE!>str<!> -> "this" }} else {{ <!CANNOT_INFER_PARAMETER_TYPE!>str<!> -> "this" }}
+    val x5: String.() -> String = if (true) {<!ARGUMENT_TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>str<!> -> "this" }<!>} else {<!ARGUMENT_TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>str<!> -> "this" }<!>}
-    val x6: String.() -> String = if (true) {{ <!CANNOT_INFER_PARAMETER_TYPE!>str<!> -> "this" }} else {{ "this" }}
+    val x6: String.() -> String = if (true) {<!ARGUMENT_TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>str<!> -> "this" }<!>} else {{ "this" }}
     val x7: String.() -> String = select({ -> this }, { -> this })
     val x8: String.() -> String = select({ this }, { this })
 }

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

@@ -15,6 +15,6 @@ fun buildTree(segments: List<Interval>): IntervalTree? = TODO()
 fun acquireIntervals(): List<Interval> = TODO()
 
 fun main() {
-    buildTree(acquireIntervals())
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>buildTree(acquireIntervals())
-        ?: emptyList()
+        ?: emptyList()<!>
 }

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

@@ -4,5 +4,5 @@ class Inv<I>
 fun <T> create(): Inv<T> = TODO()
 
 fun main() {
-    if (true) create() else null
+    <!NEW_INFERENCE_ERROR!>if (true) create() else null<!>
 }

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(<!UNRESOLVED_REFERENCE!>unresolved<!>)!!
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id(<!UNRESOLVED_REFERENCE!>unresolved<!>)!!<!>
-    <!UNRESOLVED_REFERENCE!>unresolved<!>!!!!
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!UNRESOLVED_REFERENCE!>unresolved<!>!!!!<!>
-    try {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try {
         id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     } catch (e: Exception) {
         id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
-    }
+    }<!>
 
-    if (true)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (true)
         id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     else
-        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)<!>
 
     when {
         true -> id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
     }
-    id(<!UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id(<!UNRESOLVED_REFERENCE!>unresolved<!>) ?: id(<!UNRESOLVED_REFERENCE!>unresolved<!>)<!>
 }

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

@@ -12,7 +12,7 @@ fun <T> emptyList() : List<T>? = ArrayList<T>()
 fun foo() {
     // type arguments shouldn't be required
     val l : List<Int> = emptyList()!!
-    val l1 = emptyList()!!
+    val l1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList()!!<!>
 
     checkSubtype<List<Int>>(emptyList()!!)
     checkSubtype<List<Int>?>(emptyList())

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

@@ -9,21 +9,21 @@ class Foo7<T>
 fun foo7() = null as Foo7<Int>
 
 fun poll17(flag: Boolean): Any? {
-    val inv = if (flag) { foo7() } else { ::Foo7 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (flag) { foo7() } else { ::Foo7 }<!>
     return inv
 }
 
 fun poll26(flag: Boolean): Any? {
-    val inv = when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }<!>
     return inv
 }
 
 fun poll36(flag: Boolean): Any? {
-    val inv = when (flag) { true -> ::Foo7 false -> foo7() }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() }<!>
     return inv
 }
 
 fun poll56(): Any? {
-    val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }<!>
     return inv
 }

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

@@ -44,7 +44,7 @@ fun poll13(flag: Boolean) {
 }
 
 fun poll14(flag: Boolean) {
-    val inv = if (flag) { ::bar4 } else { ::foo4 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (flag) { ::bar4 } else { ::foo4 }<!>
     <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }
 
@@ -59,7 +59,7 @@ fun poll16(flag: Boolean) {
 }
 
 fun poll17(flag: Boolean) {
-    val inv = if (flag) { foo7() } else { ::Foo7 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (flag) { foo7() } else { ::Foo7 }<!>
     inv
 }
 
@@ -79,7 +79,7 @@ fun poll22(flag: Boolean) {
 }
 
 fun poll23(flag: Boolean) {
-    val inv = when (flag) { true -> ::bar4 else -> ::foo4 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::bar4 else -> ::foo4 }<!>
     <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }
 
@@ -94,7 +94,7 @@ fun poll25(flag: Boolean) {
 }
 
 fun poll26(flag: Boolean) {
-    val inv = when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 }<!>
     inv
 }
 
@@ -114,7 +114,7 @@ fun poll32(flag: Boolean) {
 }
 
 fun poll33(flag: Boolean) {
-    val inv = when (flag) { true -> ::bar4 false -> ::foo4 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::bar4 false -> ::foo4 }<!>
     <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }
 
@@ -129,7 +129,7 @@ fun poll35(flag: Boolean) {
 }
 
 fun poll36(flag: Boolean) {
-    val inv = when (flag) { true -> ::Foo7 false -> foo7() }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>when (flag) { true -> ::Foo7 false -> foo7() }<!>
     inv
 }
 
@@ -149,7 +149,7 @@ fun poll42() {
 }
 
 fun poll43() {
-    val inv = try { ::bar4 } finally { ::foo4 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::bar4 } finally { ::foo4 }<!>
     <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }
 
@@ -184,7 +184,7 @@ fun poll52() {
 }
 
 fun poll53() {
-    val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 }<!>
     <!NO_VALUE_FOR_PARAMETER!>inv()<!>
 }
 
@@ -199,7 +199,7 @@ fun poll55() {
 }
 
 fun poll56() {
-    val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() }<!>
     inv
 }
 
@@ -254,7 +254,7 @@ fun poll72() {
 }
 
 fun poll73() {
-    val inv = ::bar4<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::bar4<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!><!>
     inv
 }
 
@@ -269,7 +269,7 @@ fun poll75() {
 }
 
 fun poll76() {
-    val inv = ::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+    val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!><!>
     inv
 }
 

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt

@@ -33,6 +33,6 @@ fun main() {
         }
     }
 
-    val f : String = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>
+    val f : String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>
     checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>)
 }

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

@@ -2,7 +2,7 @@ fun main() {
     val a : Int? = null;
     var v = 1
     val b : String = <!INITIALIZER_TYPE_MISMATCH!>v<!>;
-    val f : String = <!INITIALIZER_TYPE_MISMATCH!>a!!<!>;
+    val f : String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>a!!<!>;
     val g : String = <!INITIALIZER_TYPE_MISMATCH!>v++<!>;
     val g1 : String = <!INITIALIZER_TYPE_MISMATCH!>++v<!>;
     val h : String = <!INITIALIZER_TYPE_MISMATCH!>v--<!>;

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

@@ -4,7 +4,7 @@ class Bar {
     val a: Array<String>? = null
 }
 
-fun foo(bar: Bar) = bar.a?.asIterable() ?: emptyArray()
+fun foo(bar: Bar) = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar.a?.asIterable() ?: emptyArray()<!>
 
 fun <T> Array<out T>.asIterable(): Iterable<T> = TODO()
 

compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt

@@ -104,7 +104,7 @@ fun testTwoLambdas() {
             {}
             <!MANY_LAMBDA_EXPRESSION_ARGUMENTS!>{}<!>
         } else {
-            {}
+            <!ARGUMENT_TYPE_MISMATCH!>{}<!>
         }
     }
 }

compiler/testData/diagnostics/tests/when/kt9929.fir.kt

@@ -1,4 +1,4 @@
-val test: Int = <!INITIALIZER_TYPE_MISMATCH!>if (true) {
+val test: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>if (true) {
     when (2) {
         1 -> 1
         else -> null

compiler/testData/diagnostics/tests/when/kt9972.fir.kt

@@ -10,19 +10,19 @@
  */
 
 fun test1(): Int {
-    val x: String = if (true) {
+    val x: String = <!TYPE_MISMATCH!>if (true) {
         when {
             true -> Any()
             else -> null
         }
-    } else ""
+    } else ""<!>
     return x.hashCode()
 }
 
 fun test2(): Int {
-    val x: String = <!INITIALIZER_TYPE_MISMATCH!>when {
+    val x: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!><!TYPE_MISMATCH!>when {
                         true -> Any()
                         else -> null
-                    } ?: return 0<!>
+                    }<!> ?: return 0<!>
     return x.hashCode()
 }

compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.fir.kt

@@ -29,7 +29,7 @@ val test3: (String) -> Boolean =
 
 val test4: (String) -> Boolean =
         when {
-            true -> { s1, <!CANNOT_INFER_PARAMETER_TYPE!>s2<!> -> true }
+            true -> <!ARGUMENT_TYPE_MISMATCH!>{ s1, <!CANNOT_INFER_PARAMETER_TYPE!>s2<!> -> true }<!>
             else -> null!!
         }
 

compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.fir.kt

@@ -5,7 +5,7 @@ class ExcA : Exception()
 class ExcB : Exception()
 
 fun test2() {
-    val s: String? = <!INITIALIZER_TYPE_MISMATCH!>try {
+    val s: String? = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>try {
         ""
     }
     catch (e: ExcA) {

compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg/1.1.fir.kt

@@ -13,12 +13,12 @@ class B<T>(data: T) : A<T>(data)
 
 fun case1() {
     val tryVal: B<String> =
-    try {
+    <!TYPE_MISMATCH, TYPE_MISMATCH!>try {
         throwExceptionA(false)
         A("")
     } catch (e: Exception) {
         B("")
-    }
+    }<!>
 
 
 }
@@ -27,12 +27,12 @@ fun case1() {
 
 fun case2() {
     val tryVal: A<String> =
-    try {
+    <!TYPE_MISMATCH, TYPE_MISMATCH!>try {
         throwExceptionA(false)
         A("")
     } catch (e: Exception) {
         null
-    }
+    }<!>
 }
 
 /*
@@ -42,14 +42,14 @@ fun case2() {
  */
 fun case3() {
     val tryVal: A<Int> =
-    try {
+    <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>try {
         throwExceptionA(false)
         A(2)
     } catch (e: ExcA) {
         A(null) //diag duplication
     } catch (e: ExcB) {
         B(null) //diag duplication
-    }
+    }<!>
 }
 
 class ExcA() : Exception()

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.fir.kt

@@ -262,10 +262,10 @@ fun case_16() {
 }
 
 // TESTCASE NUMBER: 17
-val case_17 = if (nullableIntProperty == null == true == false) 0 else {
+val case_17 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (nullableIntProperty == null == true == false) 0 else {
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>nullableIntProperty<!>
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>nullableIntProperty<!><!UNSAFE_CALL!>.<!>java
-}
+}<!>
 
 //TESTCASE NUMBER: 18
 fun case_18(a: DeepObject.A.B.C.D.E.F.G.J?) {

compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.fir.kt

@@ -732,11 +732,11 @@ fun case_37(x: Nothing?, y: Nothing?) {
 fun case_38() {
     val z = null
 
-    if (<!SENSELESS_COMPARISON!>Object.prop_2 != z<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>if (<!SENSELESS_COMPARISON!>Object.prop_2 != z<!>)
     else {
         Object.prop_2
         Object.prop_2.java
-    }
+    }<!>
 }
 
 // TESTCASE NUMBER: 39