Don't report the same diagnsotics several times

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/diagnosticUtils.kt

@@ -110,7 +110,7 @@ fun ResolutionContext<*>.reportTypeMismatchDueToTypeProjection(
 }
 
 fun BindingTrace.reportDiagnosticOnce(diagnostic: Diagnostic) {
-    if (bindingContext.diagnostics.forElement(diagnostic.psiElement).any { it.factory == diagnostic.factory }) return
+    if (bindingContext.diagnostics.noSuppression().forElement(diagnostic.psiElement).any { it.factory == diagnostic.factory }) return
 
     report(diagnostic)
 }
@@ -119,8 +119,10 @@ fun BindingTrace.reportDiagnosticOnceWrtDiagnosticFactoryList(
     diagnosticToReport: Diagnostic,
     vararg diagnosticFactories: DiagnosticFactory<*>,
 ) {
-    val hasAlreadyReportedDiagnosticFromListOrSameType = bindingContext.diagnostics.forElement(diagnosticToReport.psiElement)
+    val hasAlreadyReportedDiagnosticFromListOrSameType =
-        .any { diagnostic -> diagnostic.factory == diagnosticToReport.factory || diagnosticFactories.any { it == diagnostic.factory } }
+        bindingContext.diagnostics.noSuppression()
+            .forElement(diagnosticToReport.psiElement)
+            .any { diagnostic -> diagnostic.factory == diagnosticToReport.factory || diagnosticFactories.any { it == diagnostic.factory } }
 
     if (hasAlreadyReportedDiagnosticFromListOrSameType) return
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt

@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.resolve.constants.IntegerLiteralTypeConstructor
 import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
+import org.jetbrains.kotlin.resolve.diagnostics.MutableDiagnosticsWithSuppression
 import org.jetbrains.kotlin.resolve.scopes.receivers.CastImplicitClassReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitClassReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
@@ -554,6 +555,8 @@ class TrackingBindingTrace(val trace: BindingTrace) : BindingTrace by trace {
     var reported: Boolean = false
 
     override fun report(diagnostic: Diagnostic) {
+        if (bindingContext.diagnostics.noSuppression().forElement(diagnostic.psiElement).any { it == diagnostic }) return
+
         trace.report(diagnostic)
         reported = true
     }

compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.kt

@@ -7,7 +7,7 @@ fun foo1() {}
 @Anno(x = ["a", "b"], y = "a")
 fun foo2() {}
 
-@Anno(x = <!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(arrayOf("a"), arrayOf("b"))<!>, y = "a")
+@Anno(x = <!TYPE_MISMATCH!>arrayOf(arrayOf("a"), arrayOf("b"))<!>, y = "a")
 fun foo3() {}
 
 @Anno(x = arrayOf("a", "b"), y = "a")

compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
 
 fun <T> takeFun(f: (T) -> Unit) {}
@@ -13,12 +14,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
 
 fun test() {
     takeFun<String>(::foo)
-    takeFun<String>(<!TYPE_MISMATCH, TYPE_MISMATCH!>::fooInt<!>)
+    takeFun<String>(<!TYPE_MISMATCH{NI}!>::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>fooInt<!><!>)
 
     callFun<String, Wrapper<String>>(::createWrapper)
     callFun<Int, Wrapper<Number>>(::createWrapper)
     callFun<String, Wrapper<*>>(::createWrapper)
-    callFun<String, Wrapper<Int>>(::createWrapper)
+    callFun<String, Wrapper<Int>>(::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>createWrapper<!>)
 
     callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
 }

compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
 
@@ -28,9 +29,9 @@ fun <T> test(x: T) {
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(1, null, ::foo)
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(null, null, ::foo)
 
-    val s3: Pair<Int, String?> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::foo)<!>
+    val s3: Pair<Int, String?> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
-    val s4: Pair<Int?, String> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>foo<!>)<!>
+    val s4: Pair<Int?, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
 
-    val s5: Pair<Int, String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(1, "", ::foo)<!>
+    val s5: Pair<Int, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(1, "", ::foo)<!>
     val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
 }

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

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !LANGUAGE: +ArrayLiteralsInAnnotations
 
 annotation class Foo(val a: IntArray, val b: Array<String>, val c: FloatArray)
@@ -8,7 +9,7 @@ fun test1() {}
 @Foo([], [], [])
 fun test2() {}
 
-@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
+@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
 fun test3() {}
 
 @Foo(c = [1f], b = [""], a = [1])

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

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !LANGUAGE: +ArrayLiteralsInAnnotations +BareArrayClassLiteral
 
 import kotlin.reflect.KClass
@@ -20,10 +21,10 @@ fun test3() {}
 @Foo([<!CLASS_LITERAL_LHS_NOT_A_CLASS!>Gen<Int>::class<!>])
 fun test4() {}
 
-@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
+@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[""]<!>)
 fun test5() {}
 
-@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[Int::class, 1]<!>)
+@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[Int::class, 1]<!>)
 fun test6() {}
 
 @Bar

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

@@ -1,12 +1,13 @@
+// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED
 
 fun test() {
-    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
+    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>[]<!>
     val b: Array<Int> = []
     val c = [1, 2]
     val d: Array<Int> = [1, 2]
-    val e: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
+    val e: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
 
     val f: IntArray = [1, 2]
     val g = [f]
@@ -19,5 +20,5 @@ fun check() {
     val f: IntArray = [1]
     [f] checkType { _<Array<IntArray>>() }
 
-    [1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<Any>>() }
+    [1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Array<Any>>() }
 }

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

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !LANGUAGE: +ArrayLiteralsInAnnotations
 
 annotation class Foo(
@@ -7,9 +8,9 @@ annotation class Foo(
 )
 
 annotation class Bar(
-        val a: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>,
+        val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[' ']<!>,
-        val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
+        val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
-        val c: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
+        val c: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
 )
 
 annotation class Base(
@@ -21,5 +22,5 @@ annotation class Base(
 
 annotation class Err(
         val a: IntArray = [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1L<!>],
-        val b: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
+        val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>[1]<!>
 )

compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 interface A<T> {
@@ -20,6 +21,6 @@ class D : A<Int> by baz({ it + 1 })
 
 fun <T> boo(t: T): A<T> = AImpl()
 
-class E : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH!>boo("")<!>
+class E : A<Int> by <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>boo("")<!>
 
-class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>
+class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>

compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt

@@ -18,9 +18,9 @@ fun test1(a: (Int) -> Unit) {
 }
 
 fun test2(a: (Int) -> Unit) {
-    test2(<!TYPE_MISMATCH, TYPE_MISMATCH!>fun (<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>) {}<!>)
+    test2(<!TYPE_MISMATCH!>fun (<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>) {}<!>)
 }
 
 fun test3(a: (Int, String) -> Unit) {
-    test3(<!TYPE_MISMATCH, TYPE_MISMATCH!>fun <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>)<!> {}<!>)
+    test3(<!TYPE_MISMATCH!>fun <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>x: String<!>)<!> {}<!>)
 }

compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 package a
 
 fun foo0(f: () -> String) = f
@@ -8,37 +9,37 @@ fun test1() {
     foo0 {
         ""
     }
-    foo0 <!TYPE_MISMATCH!>{
+    foo0 <!TYPE_MISMATCH{NI}!>{
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s: String<!>-> ""
     }<!>
-    foo0 <!TYPE_MISMATCH!>{
+    foo0 <!TYPE_MISMATCH{NI}!>{
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
     }<!>
 
     foo1 {
         ""
     }
-    foo1 <!TYPE_MISMATCH!>{
+    foo1 <!TYPE_MISMATCH{NI}!>{
         <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
     }<!>
-    foo1 <!TYPE_MISMATCH!>{
+    foo1 <!TYPE_MISMATCH{NI}!>{
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
     }<!>
-    foo1 <!TYPE_MISMATCH!>{
+    foo1 <!TYPE_MISMATCH{NI}!>{
-        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
     }<!>
 
 
-    foo2 <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
+    foo2 <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
         ""
     }<!>
-    foo2 <!TYPE_MISMATCH!>{
+    foo2 <!TYPE_MISMATCH{NI}!>{
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
     }<!>
-    foo2 <!TYPE_MISMATCH!>{
+    foo2 <!TYPE_MISMATCH{NI}!>{
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
     }<!>
-    foo2 <!TYPE_MISMATCH!>{
+    foo2 <!TYPE_MISMATCH{NI}!>{
-         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
+         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
     }<!>
 }

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt

@@ -1,9 +1,9 @@
 fun test(a: Int) {
     run<Int>f@{
-      if (a > 0) return@f <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
+      if (a > 0) return@f <!TYPE_MISMATCH!>""<!>
       return@f 1
     }
 
-    run<Int>{ <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
+    run<Int>{ <!TYPE_MISMATCH!>""<!> }
     run<Int>{ 1 }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt

@@ -44,7 +44,7 @@ fun test() {
     x().foo().a() checkType { _<A<String, Double, Short, Long>>() }
     x().bar() checkType { _<A<String, Double, Short, Char>>() }
 
-    x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
+    x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
 
     var y = noParameters()
     y = noParameters()

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_VALUE -VARIABLE_WITH_REDUNDANT_INITIALIZER -TOPLEVEL_TYPEALIASES_ONLY
 
@@ -45,8 +46,8 @@ class Outer<T> {
             x().foo().a() checkType { _<A<T, F, String, Double, Short, Long>>() }
             x().bar() checkType { _<A<T, F, String, Double, Short, Char>>() }
 
-            x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
+            x = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
-            x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH!>foobar<String>()<!><!>
+            x = <!TYPE_MISMATCH!>z.<!TYPE_MISMATCH{NI}!>foobar<String>()<!><!>
 
             var y = noParameters()
             y = noParameters()

compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
 
@@ -31,7 +32,7 @@ fun main() {
     checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
 
     checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
-    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.Inner()<!>)
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH{NI}!>outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>Inner()<!><!>)
 
     outer.set(outer.bar())
     outer.set(outer.Inner())

compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt

@@ -13,14 +13,14 @@ class A<E> {
 fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
     a.foo {
         val x: String = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS
-        <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
+        <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
     }
-    a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
+    a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
     a.bar { Out() }
-    a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
+    a.bar { <!TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
 
     a.foo {
-        z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
+        z.foobar(if (1 > 2) return@foo <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
-        <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
+        <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt

@@ -8,26 +8,26 @@ interface A {
 @ExperimentalStdlibApi
 fun main() {
     buildList {
-        add(<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
+        add(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
         object : A {
             override fun foo(): MutableList<String> = this@buildList
         }
     }
     buildList {
-        add(<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
+        add(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>3<!>)
         val x: String = get(0)
     }
     buildList {
-        add(<!TYPE_MISMATCH, TYPE_MISMATCH!>"3"<!>)
+        add(<!TYPE_MISMATCH!>"3"<!>)
         val x: MutableList<Int> = this@buildList
     }
     buildList {
         val y: CharSequence = ""
-        add(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>y<!>)
+        add(<!TYPE_MISMATCH, TYPE_MISMATCH!>y<!>)
         val x: MutableList<String> = this@buildList
     }
     buildList {
-        add(<!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>)
+        add(<!TYPE_MISMATCH!>""<!>)
         val x: StringBuilder = get(0)
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithLambdas.kt

@@ -147,7 +147,7 @@ fun poll73(): Flow<String> {
 
 fun poll8(): Flow<String> {
     return flow {
-        val inv = {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>} in setOf({1f})
+        val inv = {<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>} in setOf({1f})
         <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
     }
 }
@@ -175,7 +175,7 @@ fun poll83(): Flow<String> {
 
 fun poll84(): Flow<String> {
     return flow {
-        val inv = {{<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}} in setOf({{1f}})
+        val inv = {{<!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}} in setOf({{1f}})
         <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt

@@ -26,7 +26,7 @@ fun test() {
         get()?.hashCode()
         get()?.equals(1)
         // there is `String?.equals` extension
-        <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>get()<!>.equals("")
+        <!TYPE_MISMATCH("Any; Nothing?")!>get()<!>.equals("")
     }
     val ret2 = build {
         emit(1)
@@ -39,7 +39,7 @@ fun test() {
         val x = get()
         x?.hashCode()
         x?.equals(1)
-        <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
+        <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
     }
     val ret3 = build {
         emit(1)
@@ -74,7 +74,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
         }
 
         ""
@@ -84,7 +84,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
         }
 
         ""
@@ -104,7 +104,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
         }
 
         ""
@@ -114,7 +114,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
         }
 
         ""
@@ -124,7 +124,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
         }
 
         ""
@@ -144,7 +144,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
         }
 
         ""
@@ -153,7 +153,7 @@ fun test() {
         emit(1)
         emit(null)
         val x = get()
-        <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
+        <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
 
         ""
     }
@@ -211,7 +211,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
         }
 
         ""
@@ -221,7 +221,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
         }
         ""
     }
@@ -230,7 +230,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
         }
         ""
     }
@@ -239,7 +239,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x == null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
         }
         ""
     }
@@ -248,7 +248,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.equals("")
         }
 
         ""
@@ -258,7 +258,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.hashCode()
         }
         ""
     }
@@ -267,7 +267,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.toString()
         }
         ""
     }
@@ -276,7 +276,7 @@ fun test() {
         emit(null)
         val x = get()
         if (x === null) {
-            <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
+            <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
         }
         ""
     }
@@ -284,7 +284,7 @@ fun test() {
         emit(1)
         emit(null)
         val x = get()
-        <!TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?"), TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
+        <!TYPE_MISMATCH("Any; Nothing?")!>x<!>.test()
         ""
     }
     val ret51 = build {

compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt

@@ -1,16 +1,17 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
 // !CHECK_TYPE
 
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!
 
 fun test1(a: Array<in Int>) {
-    val r: Array<in Int?> = bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
+    val r: Array<in Int?> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}!>a<!>)
-    bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
+    <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}!>a<!>)
 }
 
 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!
 
 fun test2(a: Array<in Int>) {
-    val r: Array<out Array<in Int?>> = foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
+    val r: Array<out Array<in Int?>> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>a<!>)
-    foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
+    <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>a<!>)
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt

@@ -1,9 +1,10 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 fun <T> foo(array: Array<Array<T>>): Array<Array<T>> = array
 
 fun test(array: Array<Array<out Int>>) {
-    foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
+    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH{NI}!>array<!>)
 
-    val f: Array<out Array<out Int>> = foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
+    val f: Array<out Array<out Int>> = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH!>array<!>)
 }

compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt

@@ -47,7 +47,7 @@ fun bar(block: () -> String) {}
 
 fun test_5(b: Boolean) {
     bar {
-        <!TYPE_MISMATCH, TYPE_MISMATCH!>if (b) {
+        <!TYPE_MISMATCH!>if (b) {
             println("meh")
         }<!>
     }

compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.kt

@@ -119,8 +119,8 @@ fun main() {
      * K <: (A) -> Unit -> TypeVariable(_RP1) >: A
      * K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: C
      */
-    val x12 = selectC(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }<!>, id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x: B -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    val x12 = selectC(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }<!>, id <!TYPE_MISMATCH!>{ x: B -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
-    val x13 = selectA(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }<!>, id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x: C -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
+    val x13 = selectA(id <!TYPE_MISMATCH!>{ <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }<!>, id <!TYPE_MISMATCH!>{ x: C -> }<!><!NO_VALUE_FOR_PARAMETER!>)<!>
     val x14 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: A -> }, { x -> x })
     val x15 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { x: A -> }, id { x -> x })
     /*

compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/notInferableParameterOfAnonymousFunction.kt

@@ -4,13 +4,13 @@ fun <T> select(vararg x: T) = x[0]
 fun <K> id(x: K) = x
 
 fun main() {
-    val x1 = select<Any?>(id { <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>y<!> -> }, { x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> })
+    val x1 = select<Any?>(id { <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> }, { x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> })
     val x2 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!> { x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> }, { x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> })
 
     val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(fun (x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
 
     val x4 = select<Any?>((fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
-    val x5 = select<Any?>(id(fun (<!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE, CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
+    val x5 = select<Any?>(id(fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {}), fun (x: Int, <!CANNOT_INFER_PARAMETER_TYPE!>y<!>) {})
     val x6 = id<Any?>(fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>) {})
 
     select<Any?>(fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>) {}, fun (<!CANNOT_INFER_PARAMETER_TYPE!>x<!>) {})

compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt

@@ -262,8 +262,8 @@ class Main<L>(x: L?, y: L) {
     val x471 = <!DEBUG_INFO_EXPRESSION_TYPE("OutBar<OutBar<OutBar<L!!>>>")!>foo47(y)<!>
 
     fun <R> takeLambda(block: () -> R): R = materialize()
-    val x480 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L"), TYPE_MISMATCH("Any; L")!>x<!> } }<!>
+    val x480 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L")!>x<!> } }<!>
-    val x481 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L"), TYPE_MISMATCH("Any; L")!>y<!> } }<!>
+    val x481 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<L>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { <!TYPE_MISMATCH("Any; L")!>y<!> } }<!>
     val x482 = <!DEBUG_INFO_EXPRESSION_TYPE("Bar<kotlin.Nothing>")!><!DEBUG_INFO_LEAKING_THIS!>takeLambda<!> { foo48 { null } }<!>
 }
 

compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 package a
 
 class MyList<T>(t: T) {}
@@ -13,7 +14,7 @@ fun <T> readFromMyList(l: MyList<out T>, t: T) {}
 fun test1(int: Int, any: Any) {
     val a0 : MyList<Any> = getMyList(int)
 
-    val a1 : MyList<Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
+    val a1 : MyList<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
 
     val a2 : MyList<out Any> = getMyList(int)
 
@@ -28,23 +29,23 @@ fun test1(int: Int, any: Any) {
     val a7 : MyList<in Any> = getMyList(int)
 
     val a8 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
-    val a9 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
+    val a9 : MyList<in Any> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(int)<!>
 
     val a10 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
-    val a11 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
+    val a11 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
 
     val a12 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
-    val a13 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
+    val a13 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToWriteTo(any)<!>
 
     useMyList(getMyList(int), int)
     useMyList(getMyList(any), int)
-    useMyList(getMyList(int), any)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>useMyList<!>(getMyList(int), any)
 
     readFromMyList(getMyList(int), any)
     readFromMyList(getMyList(any), int)
-    readFromMyList<Int>(<!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>, int)
+    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>, int)
 
-    readFromMyList<Int>(<!TYPE_MISMATCH!>getMyListToReadFrom(any)<!>, int)
+    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(any)<!>, int)
     readFromMyList(getMyListToReadFrom(any), int)
 
     readFromMyList(getMyListToReadFrom(int), any)
@@ -53,14 +54,14 @@ fun test1(int: Int, any: Any) {
     writeToMyList(getMyList(any), int)
     writeToMyList<Any>(getMyList(int), any)
     writeToMyList(getMyList<Any>(int), any)
-    writeToMyList(getMyList(int), any)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyList(int), any)
 
     writeToMyList(getMyListToWriteTo(any), int)
-    writeToMyList(getMyListToWriteTo(int), any)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToWriteTo(int), any)
 
     readFromMyList(getMyListToWriteTo(any), any)
 
-    writeToMyList(getMyListToReadFrom(any), <!TYPE_MISMATCH!>any<!>)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToReadFrom(any), <!TYPE_MISMATCH{NI}!>any<!>)
 
     use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 //KT-2283 Bad diagnostics of failed type inference
 package a
 
@@ -9,5 +10,5 @@ fun <A, B> Foo<A>.map(f: (A) -> B): Foo<B> = object : Foo<B> {}
 
 fun foo() {
     val l: Foo<String> = object : Foo<String> {}
-    val m: Foo<String> = l.map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
+    val m: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!> }<!>
 }

compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt

@@ -1,9 +1,10 @@
+// !WITH_NEW_INFERENCE
 package typeInferenceExpectedTypeMismatch
 
 import java.util.*
 
 fun test() {
-    val s : Set<Int> = <!TYPE_MISMATCH!>newList()<!>
+    val s : Set<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>newList()<!>
     use(s)
 }
 
@@ -25,16 +26,16 @@ 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_MISMATCH!>foo(outA, inB)<!>
+    val b: Two<A, C> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>foo(outA, inB)<!>
     use(b)
 }
 
 fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
 
 fun test2(outA: Out<A>, inC: In<C>) {
-    bar(outA, <!TYPE_MISMATCH!>inC<!>)
+    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)
 
-    val b: Two<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(outA, <!TYPE_MISMATCH!>inC<!>)<!>
+    val b: Two<A, B> = <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)<!>
     use(b)
 }
 

compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 package a
 
 fun <V: U, U> foo(v: V, u: U) = u
@@ -15,7 +16,7 @@ fun <T> checkItIsExactlyAny(t: T, l: MutableList<T>) {}
 fun <V : U, U> baz(v: V, u: MutableSet<U>) = u
 
 fun test(a: Any, s: MutableSet<String>) {
-    baz(a, <!TYPE_MISMATCH, TYPE_MISMATCH!>s<!>)
+    <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>baz<!>(a, <!TYPE_MISMATCH{NI}!>s<!>)
 }
 
 //from standard library

compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !CHECK_TYPE
 // FILE: Outer.java
 
@@ -12,6 +13,6 @@ fun test(x: List<Int>, y: List<String>) {
     Outer<Int>().Inner("", y, 1) checkType { _<Outer<Int>.Inner<String>>() }
     Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
 
-    Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Outer<Int>.Inner<Any>>() }
+    Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Outer<Int>.Inner<Any>>() }
     Outer<Int>().Inner<CharSequence, String, Int>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>, 1)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt

@@ -12,7 +12,7 @@ fun test(x: Inv<Int>, y: Inv<String>) {
     A("", <!TYPE_MISMATCH!>x<!>)
     A("", y)
 
-    A<String>("", <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
+    A<String>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
 
     A<Any>("", <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
     A<String>("", y)

compiler/testData/diagnostics/tests/j+k/sam/conversionForDerivedGenericClass.kt

@@ -18,5 +18,5 @@ fun test(a: A<Runnable>, b: B, c: C<Runnable>) {
     b.f { }
     c.f { }
     C<Runnable>().f { }
-    C.g<Runnable> <!TYPE_MISMATCH, TYPE_MISMATCH!>{ }<!>
+    C.g<Runnable> <!TYPE_MISMATCH!>{ }<!>
 }

compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt

@@ -18,10 +18,10 @@ fun main() {
     J <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!> // should be prohibited, because SAM value parameter has nullable type
     J { "" + it<!UNSAFE_CALL!>.<!>length }
     J { <!NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
-    J { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
+    J { <!TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
 
     J2 <!TYPE_MISMATCH!>{ <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!>
     J2 { "" + it<!UNSAFE_CALL!>.<!>length }
     J2 { <!NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
-    J2 { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
+    J2 { <!TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
 }

compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt

@@ -33,7 +33,7 @@ fun main() {
     }
 
     A.baz {
-        x -> <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
+        x -> <!TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
     }
 
     val block: (String) -> Any? = {

compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt

@@ -1,7 +1,8 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 fun test(a: Int, b: Boolean) {
-    bar(a.foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>b<!>))
+    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!>(a.<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH!>b<!>))
 }
 
 fun <T, R> T.foo(l: (T) -> R): R = TODO()

compiler/testData/diagnostics/tests/regressions/resolveCollectionLiteralInsideLambda.kt

@@ -4,4 +4,4 @@ fun foo(l: () -> Unit) {}
 fun bar(l: () -> String) {}
 
 val a = foo { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, UNSUPPORTED!>[]<!> }
-val b = bar { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, UNSUPPORTED!>[]<!> }
+val b = bar { <!TYPE_MISMATCH, TYPE_MISMATCH, UNSUPPORTED!>[]<!> }

compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt

@@ -1,13 +1,14 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -USELESS_ELVIS
 
 fun test() {
-    bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>if (true) {
+    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>if (true) {
-        1
+        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>
     } else {
-        2
+        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>2<!>
     }<!>)
 
-    bar(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
+    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
 }
 
 fun bar(s: String) = s

compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // NI_EXPECTED_FILE
 class A(x: Int) {
@@ -20,8 +21,8 @@ val y4: B<Int> = B<Int>("")
 
 val y5: B<String> = B<String>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
 val y6: B<String> = B<String>("")
-val y7: B<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>B(1)<!>
+val y7: B<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>B(1)<!>
 val y8: B<String> = B("")
 
 val y9 = B(1)
-val y10 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>B<!>("")
+val y10 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>B<!>("")

compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 interface Foo
 interface Bar : Foo
 
@@ -12,14 +13,14 @@ val foo: Foo = run {
     <!DEBUG_INFO_SMARTCAST!>x<!>
 }
 
-val foofoo: Foo = run {
+val foofoo: Foo = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>run<!> {
     val x = foo()
     if (x == null) throw Exception()
-    <!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH!>x<!>
+    <!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH{NI}!>x<!>
 }
 
-val bar: Bar = <!TYPE_MISMATCH!>run {
+val bar: Bar = <!TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>run<!> {
     val x = foo()
     if (x == null) throw Exception()
-    <!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+    <!DEBUG_INFO_SMARTCAST{NI}, TYPE_MISMATCH!>x<!>
 }<!>

compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt

@@ -8,7 +8,7 @@ fun foo() {
             return true
         }
         <!SMARTCAST_IMPOSSIBLE!>i<!>.hashCode()
-        trans(<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>i<!>, ::can)
+        trans(<!SMARTCAST_IMPOSSIBLE!>i<!>, ::can)
         <!SMARTCAST_IMPOSSIBLE!>i<!>.hashCode()
     }
 }

compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt

@@ -16,7 +16,7 @@ fun foo(): Int {
         k.run()
         val d: Int = <!DEBUG_INFO_SMARTCAST!>c<!>
         // a is captured so smart cast is not possible
-        return d + <!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>a<!>
+        return d + <!SMARTCAST_IMPOSSIBLE!>a<!>
     }
     else return -1
 }

compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt

@@ -5,5 +5,5 @@ fun foo(x: Int, f: () -> Unit, y: Int) {}
 fun bar() {
     var x: Int?
     x = 4
-    foo(<!DEBUG_INFO_SMARTCAST!>x<!>, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, <!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>x<!>)
+    foo(<!DEBUG_INFO_SMARTCAST!>x<!>, { x = null; x<!UNSAFE_CALL!>.<!>hashCode() }, <!SMARTCAST_IMPOSSIBLE!>x<!>)
 }

compiler/testData/diagnostics/tests/smartCasts/variables/property.kt

@@ -6,5 +6,5 @@ fun bar(s: String): Int {
 
 fun foo(m: MyClass): Int {
     m.p = "xyz"
-    return bar(<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>m.p<!>)
+    return bar(<!SMARTCAST_IMPOSSIBLE!>m.p<!>)
 }

compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt

@@ -8,7 +8,7 @@ fun IntArray.forEachIndexed( op: (i: Int, value: Int) -> Unit) {
 fun max(a: IntArray): Int? {
     var maxI: Int? = null
     a.forEachIndexed { i, value ->
-        if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>maxI<!>])
+        if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE!>maxI<!>])
             maxI = i
     }
     return maxI

compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNCHECKED_CAST
+// !WITH_NEW_INFERENCE
 // SKIP_TXT
 // Issue: KT-20849
 
@@ -39,7 +40,7 @@ class Context<T>
 fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()
 
 fun <T> Any?.decodeOut1(typeFrom: Context<out T>): T {
-    return <!TYPE_MISMATCH, TYPE_MISMATCH!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: kotlin.Unit<!>
+    return <!TYPE_MISMATCH{NI}!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: <!TYPE_MISMATCH{OI}!>kotlin.Unit<!><!>
 }
 
 fun <T> Any.decodeOut2(typeFrom: Context<out T>): T {

compiler/testData/diagnostics/tests/typeParameters/kt42042.kt

@@ -1,5 +1,3 @@
-// !LANGUAGE: -ProperTypeInferenceConstraintsProcessing
-
 sealed class Subtype<A1, B1> {
     abstract fun cast(value: A1): B1
     class Trivial<A2 : B2, B2> : Subtype<A2, B2>() {
@@ -8,6 +6,6 @@ sealed class Subtype<A1, B1> {
 }
 
 fun <A, B> unsafeCast(value: A): B {
-    val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH_WARNING("B; A")!>Trivial()<!>
+    val proof: Subtype<A, B> = Subtype.<!TYPE_MISMATCH!>Trivial()<!>
     return proof.cast(value)
 }

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt

@@ -1,18 +1,19 @@
+// !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 
 class Num<Tn : Number>(val x: Tn)
 typealias N<T> = Num<T>
 
 val test0 = N(1)
-val test1 = N(<!TYPE_MISMATCH!>"1"<!>)
+val test1 = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>N<!>(<!TYPE_MISMATCH{NI}!>"1"<!>)
 
 
 class Cons<T>(val head: T, val tail: Cons<T>?)
 typealias C<T> = Cons<T>
 typealias CC<T> = C<C<T>>
 
-val test2 = C(1, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
+val test2 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>C<!>(1, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
-val test3 = CC(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
+val test3 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>CC<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
 val test4 = CC(C(1, null), null)
 
 
@@ -20,13 +21,13 @@ class Pair<X, Y>(val x: X, val y: Y)
 typealias PL<T> = Pair<T, List<T>>
 typealias PN<T> = Pair<T, Num<T>>
 
-val test5 = PL(1, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+val test5 = <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>PL<!>(1, <!NULL_FOR_NONNULL_TYPE!>null<!>)
 
 
 class Foo<T>(val p: Pair<T, T>)
 typealias F<T> = Foo<T>
 
-fun testProjections1(x: Pair<in Int, out String>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
+fun testProjections1(x: Pair<in Int, out String>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
-fun testProjections2(x: Pair<in Int, out Number>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
+fun testProjections2(x: Pair<in Int, out Number>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)
-fun testProjections3(x: Pair<in Number, out Int>) = F(<!TYPE_MISMATCH!>x<!>)
+fun testProjections3(x: Pair<in Number, out Int>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}!>x<!>)
-fun testProjections4(x: Pair<in Int, in Int>) = F(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
+fun testProjections4(x: Pair<in Int, in Int>) = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>F<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>x<!>)

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt

@@ -13,6 +13,6 @@ typealias C<T> = Cons<T>
 typealias C2<T> = MapLike<T>
 
 val test1 = C(1, C(2, null))
-val test2 = C(1, <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>C(<!TYPE_MISMATCH, TYPE_MISMATCH!>""<!>, null)<!>)
+val test2 = C(1, <!TYPE_MISMATCH!>C(<!TYPE_MISMATCH!>""<!>, null)<!>)
-val test23 = <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>if (true) 1 else null<!>)<!>
+val test23 = <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(if (true) 1 else null)<!>
-val test234 = C2(<!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>if (true) 1 else null<!>)<!>)
+val test234 = C2(<!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION_BASED_ON_JAVA_ANNOTATIONS!>C2(if (true) 1 else null)<!>)

compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt

@@ -62,7 +62,7 @@ fun test() {
 
     takeUByte(<!TYPE_MISMATCH!>LONG_CONST<!>)
     takeUByte(<!TYPE_MISMATCH!>NON_CONST<!>)
-    takeUByte(<!TYPE_MISMATCH, TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
+    takeUByte(<!TYPE_MISMATCH!>BIGGER_THAN_UBYTE<!>)
     takeUByte(<!TYPE_MISMATCH!>UINT_CONST<!>)
     takeUIntWithoutAnnotaion(<!TYPE_MISMATCH!>IMPLICIT_INT<!>)
 }

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

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 /*
  * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE)
  *
@@ -10,18 +11,18 @@
  */
 
 fun test1(): Int {
-    val x: String = if (true) <!TYPE_MISMATCH!>{
+    val x: String = if (true) <!TYPE_MISMATCH{NI}!>{
         when {
-            true -> Any()
+            true -> <!TYPE_MISMATCH{OI}!>Any()<!>
-            else -> null
+            else -> <!NULL_FOR_NONNULL_TYPE{OI}!>null<!>
         }
     }<!> else ""
     return x.hashCode()
 }
 
 fun test2(): Int {
-    val x: String = <!TYPE_MISMATCH, TYPE_MISMATCH!>when {
+    val x: String = <!TYPE_MISMATCH{NI}!>when {
-                        true -> Any()
+                        true -> <!TYPE_MISMATCH{OI}!>Any()<!>
                         else -> null
                     } ?: return 0<!>
     return x.hashCode()

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 import kotlin.reflect.KClass
 
 open class A
@@ -12,7 +14,7 @@ class MyClass1
 @Ann1(arrayOf(Any::class))
 class MyClass1a
 
-@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B1::class<!>)<!>)
+@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B1::class<!>)<!>)
 class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -23,5 +25,5 @@ class MyClass3
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
+@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 
 import kotlin.reflect.KClass
 
@@ -10,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
 @Ann1(arrayOf(A::class))
 class MyClass1
 
-@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>Any::class<!>)<!>)
+@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>Any::class<!>)<!>)
 class MyClass1a
 
 @Ann1(arrayOf(B1::class))
@@ -18,11 +19,11 @@ class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<out B1>>)
 
-@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>A::class<!>)<!>)
+@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>A::class<!>)<!>)
 class MyClass3
 
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(<!TYPE_MISMATCH, TYPE_MISMATCH!>arrayOf(<!TYPE_MISMATCH!>B2::class<!>)<!>)
+@Ann2(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>arrayOf(<!TYPE_MISMATCH{NI}!>B2::class<!>)<!>)
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.kt

@@ -37,6 +37,6 @@ class B {
 }
 
 fun foo3(x: B) = {
-    x += { <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
+    x += { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
     x += id { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt

@@ -1,5 +1,6 @@
 // !USE_EXPERIMENTAL: kotlin.RequiresOptIn
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 
 @file:OptIn(ExperimentalTypeInference::class)
@@ -14,10 +15,10 @@ fun <S> generate(@BuilderInference g: suspend Controller<S>.() -> Unit): S = TOD
 
 class A
 
-val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+val test1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>generate<!> {
     yield(<!NO_COMPANION_OBJECT!>A<!>)
 }
 
-val test2: Int = <!TYPE_MISMATCH!>generate {
+val test2: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>generate {
-    yield(<!TYPE_MISMATCH, TYPE_MISMATCH!>A()<!>)
+    yield(<!TYPE_MISMATCH{NI}!>A()<!>)
 }<!>

compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt

@@ -28,7 +28,7 @@ fun foo() {
     i = genericBuilder { 1 }
     genericBuilder { 1 }
     genericBuilder<Int> { 1 }
-    genericBuilder<Int> { <!TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
+    genericBuilder<Int> { <!TYPE_MISMATCH!>""<!> }
 
     val y = { 1 }
     genericBuilder(<!UNSUPPORTED_FEATURE!>y<!>)
@@ -43,7 +43,7 @@ fun foo() {
     val s: String = manyArgumentsBuilder({}, { "" }) { 1 }
 
     manyArgumentsBuilder<String>({}, { "" }, { 1 })
-    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
+    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
 
     severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
         x checkType { _<String>() }

compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
 
 suspend fun <V> await(f: V): V = f
 
@@ -7,10 +8,10 @@ fun <T> genericBuilder(c: suspend () -> T): T = null!!
 fun foo() {
     var result = ""
     genericBuilder<String> {
-        <!TYPE_MISMATCH, TYPE_MISMATCH!>try {
+        <!TYPE_MISMATCH{NI}!>try {
             await("")
         } catch(e: Exception) {
-            result = "fail"
+            <!EXPECTED_TYPE_MISMATCH{OI}!>result = "fail"<!>
         }<!>
     }
 }

compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt

@@ -1,3 +1,5 @@
+// !WITH_NEW_INFERENCE
+
 // FILE: P.java
 
 import java.util.ArrayList;
@@ -13,5 +15,5 @@ public class P {
 
 fun foo(c: P): MutableList<Int> {
     // Error should be here: see KT-8168 Typechecker fails for platform collection type
-    return <!TYPE_MISMATCH, TYPE_MISMATCH!>c.getList() ?: listOf()<!>
+    return <!TYPE_MISMATCH{NI}!>c.getList() ?: <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{OI}!>listOf()<!><!>
 }

compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.kt

@@ -19,7 +19,7 @@ fun main() {
     val x1: suspend (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>{ x -> x }<!>)
 
     // Here, the error should be
-    val x2: (Int) -> Unit = <!TYPE_MISMATCH!>takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)<!>
+    val x2: (Int) -> Unit = <!TYPE_MISMATCH!>takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH!>{ x -> x }<!>)<!>
-    val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)
+    val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit")!>id <!TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH!>{ x -> x }<!>)
-    val x4: (Int) -> Unit = <!TYPE_MISMATCH, TYPE_MISMATCH!>takeSimpleFunction(<!TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>{}<!>)<!>
+    val x4: (Int) -> Unit = <!TYPE_MISMATCH, TYPE_MISMATCH!>takeSimpleFunction(<!TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("suspend (kotlin.Int) -> kotlin.Unit"), TYPE_MISMATCH!>{}<!>)<!>
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 //KT-4711 Error type with no error reported from type inference
 
 fun main() {
@@ -6,15 +7,15 @@ fun main() {
     val startTimeNanos = System.nanoTime()
 
     // the problem sits on the next line:
-    val pi = 4.0.toDouble() * delta * (1..n).reduce(
+    val pi = 4.0.toDouble() * delta <!OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>*<!> (1..n).<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>reduce<!>(
             {t, i ->
                 val x = (i - 0.5) * delta
-                <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>t + 1.0 / (1.0 + x * x)<!>
+                <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>t + 1.0 / (1.0 + x * x)<!>
 
             })
     // !!! pi has error type here
 
     val elapseTime = (System.nanoTime() - startTimeNanos) / 1e9
 
-    println("pi_sequential_reduce $pi $n $elapseTime")
+    println("pi_sequential_reduce $<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>pi<!> $n $elapseTime")
 }

compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt

@@ -3,7 +3,7 @@
 fun indexOfMax(a: IntArray): Int? {
     var maxI: Int? = null
     a.forEachIndexed { i, value ->
-        if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>maxI<!>]) {
+        if (maxI == null || value >= a[<!SMARTCAST_IMPOSSIBLE!>maxI<!>]) {
             maxI = i
         }
     }

compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt

@@ -1,3 +1,4 @@
+// !WITH_NEW_INFERENCE
 // SKIP_TXT
 
 class ExcA : Exception()
@@ -26,9 +27,9 @@ fun test1(): Map<Int, Int> = run {
 }
 
 fun test2(): Map<Int, Int> = run {
-    <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>try {
+    <!TYPE_MISMATCH{NI}!>try {
         emptyMap()
     } catch (e: ExcA) {
-        <!TYPE_MISMATCH!>mapOf(<!TYPE_MISMATCH!>"" to ""<!>)<!>
+        <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>mapOf(<!TYPE_MISMATCH{NI}!>"" to ""<!>)<!>
     }<!>
 }