diff --git a/compiler/testData/codegen/box/coroutines/kt30858.kt b/compiler/testData/codegen/box/coroutines/kt30858.kt
index 4cbf13241bd..447a06a605b 100644
--- a/compiler/testData/codegen/box/coroutines/kt30858.kt
+++ b/compiler/testData/codegen/box/coroutines/kt30858.kt
@@ -19,7 +19,7 @@ fun myLaunch(
 public fun <E> myProduce(@BuilderInference block: suspend MyProducerScope<E>.() -> Unit) {}
 
 fun <T> MyReceiveChannel<T>.debounce(period: Long) {
-    myProduce {
+    myProduce<Any> {
         myConsumeEach {
             myLaunch {
                 myDelay(period)
diff --git a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt
index 9bb5e8c019c..39173da547c 100644
--- a/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt
+++ b/compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt
@@ -45,7 +45,7 @@ fun main(args : Array<String>) {
 
     val b = fooT2<Int>()(1)
     checkSubtype<Int>(b)
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
 
     <!FUNCTION_EXPECTED!>1<!>()
     <!FUNCTION_EXPECTED!>1<!>{}
diff --git a/compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt b/compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt
index eaae15e42e0..1fa35d93abb 100644
--- a/compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt
+++ b/compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt
@@ -5,7 +5,7 @@ fun test(<!UNUSED_PARAMETER!>a<!> : java.lang.annotation.RetentionPolicy) {
 }
 
 fun test() {
-  java.util.Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+  java.util.Collections.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
   val <!UNUSED_VARIABLE!>a<!> : Collection<String>? = java.util.Collections.emptyList()
 }
 
diff --git a/compiler/testData/diagnostics/tests/ResolveToJava.kt b/compiler/testData/diagnostics/tests/ResolveToJava.kt
index d3af0fcd7cb..fe0b5775408 100644
--- a/compiler/testData/diagnostics/tests/ResolveToJava.kt
+++ b/compiler/testData/diagnostics/tests/ResolveToJava.kt
@@ -21,10 +21,10 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util
 
   val <!UNUSED_VARIABLE!>f<!> : java.io.File? = null
 
-  Collections.<!FUNCTION_CALL_EXPECTED, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
+  Collections.<!FUNCTION_CALL_EXPECTED, NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
   Collections.<!FUNCTION_CALL_EXPECTED!>emptyList<Int><!>
   Collections.emptyList<Int>()
-  Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+  Collections.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 
   checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
   Collections.singleton<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>)
diff --git a/compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt b/compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt
index 525d57ad2e8..91fa86bc7ba 100644
--- a/compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt
+++ b/compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt
@@ -1,13 +1,15 @@
+// !WITH_NEW_INFERENCE
+
 fun <T> getT() {}
 fun <A, B> getTT() {}
 fun <A, B, C> getTTT(<!UNUSED_PARAMETER!>x<!> : Any) {}
 fun foo(<!UNUSED_PARAMETER!>a<!> : Any?) {}
 
 public fun main() {
-    getT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
     <!UNRESOLVED_REFERENCE!>ggetT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    getTT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    getTT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
-    getTT<Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    foo(getTTT<Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    foo(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
 }
diff --git a/compiler/testData/diagnostics/tests/TypeInference.kt b/compiler/testData/diagnostics/tests/TypeInference.kt
index e467af5c690..124ebe886bd 100644
--- a/compiler/testData/diagnostics/tests/TypeInference.kt
+++ b/compiler/testData/diagnostics/tests/TypeInference.kt
@@ -10,10 +10,10 @@ fun main() {
   val <!UNUSED_VARIABLE!>a<!> : C<Int> = C();
   val <!UNUSED_VARIABLE!>x<!> : C<in String> = C()
   val <!UNUSED_VARIABLE!>y<!> : C<out String> = C()
-  val <!UNUSED_VARIABLE!>z<!> : C<*> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
+  val <!UNUSED_VARIABLE!>z<!> : C<*> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
 
   val <!UNUSED_VARIABLE!>ba<!> : C<Int> = bar();
   val <!UNUSED_VARIABLE!>bx<!> : C<in String> = bar()
   val <!UNUSED_VARIABLE!>by<!> : C<out String> = bar()
-  val <!UNUSED_VARIABLE!>bz<!> : C<*> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
+  val <!UNUSED_VARIABLE!>bz<!> : C<*> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt
index 5c12daf7743..dc76a67d9fe 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt
@@ -7,5 +7,5 @@ fun foo(y: String) {}
 fun <T> bar(f: (T) -> Unit) {}
 
 fun test() {
-    bar(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt
index ac9fca6cd1b..f87cc868867 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt
@@ -17,21 +17,21 @@ class B {
 fun <T> bar(f: (T) -> Unit): T = TODO()
 
 fun test() {
-    myWith(A()) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>myWith<!>(A()) {
         val t1 = bar(::foo)
         <!DEBUG_INFO_EXPRESSION_TYPE("A")!>t1<!>
 
         val t2 = bar(::baz)
         <!DEBUG_INFO_EXPRESSION_TYPE("A")!>t2<!>
 
-        myWith(B()) {
+        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>myWith<!>(B()) {
             val a: A = bar(::foo)
             val b: B = bar(::foo)
 
             val t3 = bar(::baz)
             <!DEBUG_INFO_EXPRESSION_TYPE("B")!>t3<!>
 
-            <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER, IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>bar<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
+            <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt
index dbf3b93e70b..8c4b8a3c168 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt
@@ -31,5 +31,5 @@ fun test() {
     val a6 = foo(::singleA, ::singleB)
     <!DEBUG_INFO_EXPRESSION_TYPE("{A & B}")!>a6<!>
 
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>foo<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>multiple<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED!>multiple<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>multiple<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED!>multiple<!>)
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt b/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt
index 9251adf33f4..709a0e84556 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt
@@ -9,4 +9,4 @@ fun foo(s: String) {}
 
 val x1 = apply(1, ::foo)
 val x2 = apply("hello", ::foo)
-val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>x3<!> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)
\ No newline at end of file
+val x3 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.ni.txt b/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.ni.txt
index 06a6723ae50..556cd82d2a9 100644
--- a/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.ni.txt
+++ b/compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.ni.txt
@@ -2,7 +2,7 @@ package
 
 public val x1: kotlin.Unit
 public val x2: kotlin.Unit
-public val x3: kotlin.Nothing
+public val x3: ???
 public fun </*0*/ T, /*1*/ R> apply(/*0*/ x: T, /*1*/ f: (T) -> R): R
 public fun foo(/*0*/ i: kotlin.Int): kotlin.Unit
 public fun foo(/*0*/ s: kotlin.String): kotlin.Unit
diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt b/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
index b75672b70d7..e00cdf7503b 100644
--- a/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
+++ b/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt
@@ -3,7 +3,7 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED
 
 fun test() {
-    val a = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
+    val a = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
     val b: Array<Int> = []
     val c = [1, 2]
     val d: Array<Int> = [1, 2]
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
index b4788b32450..fb7a9e02f5d 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
@@ -10,10 +10,10 @@ class A(outer: Outer) {
     var g: String by  outer.getContainer().getMyProperty()
 
 
-    var b: String by  foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var r: String by  foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
+    var b: String by  foo(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
+    var r: String by  foo(outer.getContainer().<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
+    var e: String by  <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
+    var f: String by  <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1
 }
 
 fun <A, B> foo(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
index 13cdf6a375e..e872b5a72d8 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
@@ -8,7 +8,7 @@ class A<R>() {
     operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
 }
 
-var a1: Int by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()
+var a1: Int by <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()
 var a2: Int by A<String>()
 
 class B<R>() {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt
index c0e232104eb..79f128e42cf 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt
@@ -4,7 +4,7 @@
 import kotlin.reflect.KProperty
 
 var a: Int by A()
-var a1 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>A()<!>
+var a1 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>A()<!>
 
 var b: Int by B()
 
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt
index 974b7716391..488055ba112 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt
@@ -3,7 +3,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-    var a by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()
+    var a by <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()
 }
 
 class MyProperty<T, R> {
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.ni.txt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.ni.txt
index 35889d9c662..316fad2cbc7 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.ni.txt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.ni.txt
@@ -2,7 +2,7 @@ package
 
 public final class A {
     public constructor A()
-    public final var a: kotlin.Any?
+    public final var a: ???
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt
index a32cc11b30f..ee0741ebe16 100644
--- a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt
+++ b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt
@@ -20,7 +20,7 @@ class A
 infix operator fun A.plus(<!UNUSED_PARAMETER!>a<!> : Any) {
 
   1.foo()
-  true.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+  true.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
 
   <!UNUSED_EXPRESSION!>1<!>
 }
diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt b/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt
index 6b034e53e90..4f6e830cd0b 100644
--- a/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt
+++ b/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt
@@ -12,7 +12,7 @@ fun test(a: (Int) -> Int) {
 }
 
 fun test2(a: () -> List<Int>) {
-    test2(fun () = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>())
+    test2(fun () = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>())
 }
 
 val a: (Int) -> Unit = fun(x) { checkSubtype<Int>(x) }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt
index a921616a278..7c1ba5de89a 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt
@@ -30,8 +30,8 @@ fun bar(aInstance: A, bInstance: B) {
         d checkType { _<Short>() }
     }
 
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bInstance) {
-        <!OI;CANNOT_INFER_PARAMETER_TYPE!>(<!NI;COMPONENT_FUNCTION_MISSING!>a<!>, <!NI;COMPONENT_FUNCTION_MISSING!>b<!>)<!>, (c, d) ->
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bInstance) {
+        <!CANNOT_INFER_PARAMETER_TYPE!>(a, b)<!>, (c, d) ->
         <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
         <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
         c checkType { _<Double>() }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt
index 037dec7797e..0ad96640de8 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt
@@ -1,18 +1,18 @@
 // !WITH_NEW_INFERENCE
 fun test() {
     run {<!RETURN_NOT_ALLOWED!>return<!>}
-    <!NI;UNREACHABLE_CODE!>run {}<!>
+    run {}
 }
 
 fun test2() {
     run {<!RETURN_NOT_ALLOWED!>return@test2<!>}
-    <!NI;UNREACHABLE_CODE!>run {}<!>
+    run {}
 }
 
 fun test3() {
     fun test4() {
         run {<!RETURN_NOT_ALLOWED!>return@test3<!>}
-        <!NI;UNREACHABLE_CODE!>run {}<!>
+        run {}
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt
index ef0a0ba73f8..6ec1d9b2362 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt
@@ -19,7 +19,7 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
     a.foo1(<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>())
     a.foo1(Out<Nothing>())
 
-    a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
+    a.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
     a.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo2<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Inv<CharSequence>()<!>)
     a.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Inv()<!>)
 
@@ -31,7 +31,7 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
     b.foo1(Out<CharSequence>())
     b.foo1<Out<CharSequence>>(Out())
 
-    b.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
+    b.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
     b.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo2<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Inv<CharSequence>()<!>)
     b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Inv()<!>)
 
diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt
index 33dce1700e1..3597b3f194c 100644
--- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt
+++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt
@@ -4,7 +4,7 @@ class C<<!REIFIED_TYPE_PARAMETER_NO_INLINE!>reified<!> T>
 fun <T> id(p: T): T = p
 
 fun <A> main() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
 
     val <!UNUSED_VARIABLE!>a<!>: C<A> = <!TYPE_PARAMETER_AS_REIFIED!>C<!>()
     C<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()
diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt
index e8290732d73..9365da850d2 100644
--- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt
+++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt
@@ -6,13 +6,13 @@ inline fun <reified T> f(): T = throw UnsupportedOperationException()
 fun <T> id(p: T): T = p
 
 fun <A> main() {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f<!>()
 
-    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>a<!>: A = <!TYPE_PARAMETER_AS_REIFIED!>f<!>()<!>
-    <!NI;UNREACHABLE_CODE!>f<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()<!>
+    val <!UNUSED_VARIABLE!>a<!>: A = <!TYPE_PARAMETER_AS_REIFIED!>f<!>()
+    f<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()
 
-    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>b<!>: Int = f()<!>
-    <!NI;UNREACHABLE_CODE!>f<Int>()<!>
+    val <!UNUSED_VARIABLE!>b<!>: Int = f()
+    f<Int>()
 
-    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!NI;TYPE_PARAMETER_AS_REIFIED, TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
+    val <!UNUSED_VARIABLE!>с<!>: A = id(<!NI;TYPE_PARAMETER_AS_REIFIED, TYPE_PARAMETER_AS_REIFIED!>f<!>())
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt b/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt
index cee31ed0e29..f3ff59c862a 100644
--- a/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt
+++ b/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt
@@ -10,7 +10,7 @@ fun test1() {
 }
 
 fun test2() {
-    val m0 = java.util.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>HashMap<!>()
+    val m0 = java.util.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>HashMap<!>()
     val m1 = java.util.HashMap<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String, String, String><!>()
     val m2 = java.util.HashMap<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt
index 28e8c2da190..aa1018a0275 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt
@@ -7,7 +7,7 @@ interface A<T>
 fun <T> infer(<!UNUSED_PARAMETER!>a<!>: A<T>) : T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 fun test(nothing: Nothing?) {
-    <!NI;UNREACHABLE_CODE!>val <!UNUSED_VARIABLE!>i<!> =<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_INCORPORATION_ERROR!>infer<!>(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>nothing<!>)
+    val <!UNUSED_VARIABLE!>i<!> = <!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>infer<!>(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>nothing<!>)
 }
 
 fun sum(<!UNUSED_PARAMETER!>a<!> : IntArray) : Int {
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt
index 3155721577f..16e9526a5dc 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt
@@ -6,6 +6,6 @@ fun <T, R> foo(<!UNUSED_PARAMETER!>map<!>: Map<T, R>) : R = throw Exception()
 fun <F, G> getMap() : Map<F, G> = throw Exception()
 
 fun bar123() {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMap<!>(
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMap<!>(
 <!SYNTAX!><!>}
 
diff --git a/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt b/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt
index 6adda742074..39a4dc86ce6 100644
--- a/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt
+++ b/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt
@@ -4,7 +4,7 @@ fun <T: Any> fooT22() : T? {
 }
 
 fun foo1() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
 }
 
 val n : Nothing = null.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>sure<!>()
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt
index c0fda0307c8..f76f9bd8751 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt
@@ -22,5 +22,5 @@ val b: () -> Unit = l@{
 val c: () -> Unit = {
     // Interesting enough, for such expessions we use expected type Unit
     // (compare that with the previous case, where we didn't used expected type Unit for "hello")
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>materialize<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt
index 18434688c14..7350ae0a2b4 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt
@@ -3,11 +3,11 @@
 fun <T : Number> materializeNumber(): T = TODO()
 
 fun a(): Unit = run {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
 }
 
 fun b(): Unit = run {
-    run {
-        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> {
+        <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt
index 81176e8df24..9cfb3f61ced 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt
@@ -14,6 +14,6 @@ fun implicitCoercion() {
 
     val <!UNUSED_VARIABLE!>c<!> = l@{
         // Error: block doesn't have an expected type, so call can't be inferred!
-        <!NI;UNREACHABLE_CODE!>return@l<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        return@l <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt
index 34e7ffb3f27..a65aa2996d3 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt
@@ -11,15 +11,15 @@ fun a(): Unit = run {
 
 fun b(): Unit = run {
     // Ok, expected type is applied
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>materialize<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
 }
 
 fun c(): Unit = run {
-    run {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> {
         // Attention!
         // In OI expected type 'Unit' isn't applied here because of implementation quirks (note that OI still applies Unit in case 'e')
         // In NI, it is applied and call is correctly inferred, which is consistent with the previous case
-        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt
index 4b0cc5f4f2a..fe277112039 100644
--- a/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt
+++ b/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt
@@ -7,7 +7,7 @@ fun <T> foo() = foo() <!UNCHECKED_CAST!>as T<!>
 
 fun <T> foo2(): T = TODO()
 
-val test = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>plus<!>("") <!NI;USELESS_CAST!>as String<!>
+val test = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>plus<!>("") as String
 
 fun <T> T.bar() = this
 val barTest = "".bar() <!CAST_NEVER_SUCCEEDS!>as<!> Number
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt
index 64adc92aaa6..e693f4265b7 100644
--- a/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt
+++ b/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt
@@ -9,10 +9,10 @@ class A {
 
 fun <V> id(value: V) = value
 
-val asA = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+val asA = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
 
-val receiverParenthesized = (<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
-val no2A = A().<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+val receiverParenthesized = (<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+val no2A = A().<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
 
 val correct1 = A().fooA() as A
 val correct2 = foo<A>().fooA() as A
diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt
index a1b370c3d9f..16c79581202 100644
--- a/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt
+++ b/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt
@@ -7,7 +7,7 @@ fun <V> id(value: V) = value
 
 val asString = foo() as String
 
-val viaId = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
+val viaId = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
 
 val insideId = id(foo() as String)
 
@@ -17,5 +17,5 @@ val asStarList = foo() as List<*>
 
 val safeAs = foo() as? String
 
-val fromIs = <!NI;USELESS_IS_CHECK!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is String<!>
-val fromNoIs = <!NI;USELESS_IS_CHECK!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() !is String<!>
+val fromIs = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is String
+val fromNoIs = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() !is String
diff --git a/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt b/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt
index c80d41d6f80..3ee7c4cc974 100644
--- a/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt
+++ b/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt
@@ -11,5 +11,5 @@ fun test() {
     val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
     checkSubtype<Int>(q)
 
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/kt28654.kt b/compiler/testData/diagnostics/tests/inference/kt28654.kt
index cf734d7057a..46e7e16afb2 100644
--- a/compiler/testData/diagnostics/tests/inference/kt28654.kt
+++ b/compiler/testData/diagnostics/tests/inference/kt28654.kt
@@ -6,5 +6,5 @@ fun <K> select(): K = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMAT
 
 fun test() {
     val x: Int = select()
-    <!NI;UNREACHABLE_CODE!>val t =<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
+    val t = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/kt6175.kt b/compiler/testData/diagnostics/tests/inference/kt6175.kt
index e8528f64c10..d06a41f36f1 100644
--- a/compiler/testData/diagnostics/tests/inference/kt6175.kt
+++ b/compiler/testData/diagnostics/tests/inference/kt6175.kt
@@ -4,46 +4,46 @@
 fun <T, R : Any> foo(body: (R?) -> T): T = fail()
 
 fun test1() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+        true
+    }
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        true
     }
-    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
-    }<!>
 }
 
 
 fun <T, R> bar(body: (R) -> T): T = fail()
 
 fun test2() {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
+        true
+    }
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        true
     }
-    <!NI;UNREACHABLE_CODE!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
-    }<!>
 }
 
 fun <T, R> baz(body: (List<R>) -> T): T = fail()
 
 fun test3() {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
+        true
+    }
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        true
     }
-    <!NI;UNREACHABLE_CODE!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
-    }<!>
 }
 
 fun <T, R : Any> brr(body: (List<R?>) -> T): T = fail()
 
 fun test4() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
+        true
+    }
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        true
     }
-    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
-    }<!>
 }
 
 fun fail(): Nothing = throw Exception()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt b/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt
index 3a58828b7f6..6ae1bb2865e 100644
--- a/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt
+++ b/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt
@@ -14,7 +14,7 @@ fun <T> id(t: T): T = t
 infix fun <T> Z.foo(a: A<T>): A<T> = a
 
 fun test(z: Z) {
-    z <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
+    z <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
     val a: A<Int> = id(z foo newA())
     val b: A<Int> = id(z.foo(newA()))
     use(a, b)
@@ -24,19 +24,19 @@ fun test(z: Z) {
 operator fun <T> Z.plus(a: A<T>): A<T> = a
 
 fun test1(z: Z) {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(z <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
-    <!NI;UNREACHABLE_CODE!>val a: A<Z> = z + newA()<!>
-    <!NI;UNREACHABLE_CODE!>val b: A<Z> = z.plus(newA())<!>
-    <!NI;UNREACHABLE_CODE!>val c: A<Z> = id(z + newA())<!>
-    <!NI;UNREACHABLE_CODE!>val d: A<Z> = id(z.plus(newA()))<!>
-    <!NI;UNREACHABLE_CODE!>use(a, b, c, d)<!>
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(z <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>+<!> <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    val a: A<Z> = z + newA()
+    val b: A<Z> = z.plus(newA())
+    val c: A<Z> = id(z + newA())
+    val d: A<Z> = id(z.plus(newA()))
+    use(a, b, c, d)
 }
 
 //comparison operation
 operator fun <T> Z.compareTo(a: A<T>): Int { use(a); return 1 }
 
 fun test2(z: Z) {
-    val a: Boolean = id(z <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    val a: Boolean = id(z <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><<!> <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
     val b: Boolean = id(z < newA<Z>())
     use(a, b)
 }
@@ -45,26 +45,26 @@ fun test2(z: Z) {
 fun Z.<!EXTENSION_SHADOWED_BY_MEMBER!>equals<!>(any: Any): Int { use(any); return 1 }
 
 fun test3(z: Z) {
-    z <!NI;EQUALS_MISSING!>==<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
+    z <!NI;EQUALS_MISSING!>==<!> <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
     z == newA<Z>()
-    id(z <!NI;EQUALS_MISSING!>==<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    id(z <!NI;EQUALS_MISSING!>==<!> <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
     id(z == newA<Z>())
 
-    id(z === <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    id(z === <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
     id(z === newA<Z>())
 }
 
 //'in' operation
 fun test4(collection: Collection<A<*>>) {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>() in collection)
-    <!NI;UNREACHABLE_CODE!>id(newA<Int>() in collection)<!>
+    id(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>() in collection)
+    id(newA<Int>() in collection)
 }
 
 //boolean operations
 fun <T> toBeOrNot(): Boolean = throw Exception()
 
 fun test5() {
-    if (<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>() && <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>()) {}
+    if (<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>() && <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>()) {}
     if (toBeOrNot<Int>() && toBeOrNot<Int>()) {}
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt b/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt
index d225137851c..b08fc1b568f 100644
--- a/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt
+++ b/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt
@@ -5,7 +5,7 @@ package noInformationForParameter
 import java.util.*
 
 fun test() {
-    val <!UNUSED_VARIABLE!>n<!> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newList<!>()
+    val <!UNUSED_VARIABLE!>n<!> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newList<!>()
 
     val <!UNUSED_VARIABLE!>n1<!> : List<String> = newList()
 }
diff --git a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt
index 82dcf83876b..061413babac 100644
--- a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt
+++ b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt
@@ -3,7 +3,7 @@ fun foo() {
     fun bar1() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar1<!>()<!>
 
     fun bar2() = 1 + <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar2<!>()<!>
-    fun <!NI;IMPLICIT_NOTHING_RETURN_TYPE!>bar3<!>() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar3<!>()<!>)
+    fun bar3() = id(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar3<!>()<!>)
 }
 
 fun <T> id(x: T) = x
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt
index 3b09028dc2b..bf6cb78a2a6 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt
@@ -5,7 +5,7 @@
 package n
 
 fun main() {
-    val <!UNUSED_VARIABLE!>a<!> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
+    val <!UNUSED_VARIABLE!>a<!> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
     val <!UNUSED_VARIABLE!>a0<!> : Array<Array<Int>> = array(array())
     val a1 = array(array<Int>())
     checkSubtype<Array<Array<Int>>>(a1)
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt
index d59e9d80967..a9d9f2a8bd1 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt
@@ -4,7 +4,7 @@
 package a
 
 fun main() {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {
 
     }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt
index ce50f71f86b..5f0417bd072 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt
@@ -7,5 +7,5 @@ fun <T> fooT2() : (t : T) -> T {
 }
 
 fun test() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // here 1 should not be marked with an error
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // here 1 should not be marked with an error
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt
index 8f55a0a7952..42480796d15 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt
@@ -12,12 +12,12 @@ fun <T> emptyList() : List<T>? = ArrayList<T>()
 fun foo() {
     // type arguments shouldn't be required
     val <!UNUSED_VARIABLE!>l<!> : List<Int> = emptyList()!!
-    <!NI;UNREACHABLE_CODE!>val <!UNUSED_VARIABLE!>l1<!> =<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()!!
+    val <!UNUSED_VARIABLE!>l1<!> = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>!!<!>
 
-    <!NI;UNREACHABLE_CODE!>checkSubtype<List<Int>>(emptyList()!!)<!>
-    <!NI;UNREACHABLE_CODE!>checkSubtype<List<Int>?>(emptyList())<!>
+    checkSubtype<List<Int>>(emptyList()!!)
+    checkSubtype<List<Int>?>(emptyList())
 
-    <!NI;UNREACHABLE_CODE!>doWithList(emptyList()!!)<!>
+    doWithList(emptyList()!!)
 }
 
 fun doWithList(list: List<Int>) = list
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt
index e1f885429db..22d3d719d21 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt
@@ -11,7 +11,7 @@ fun test() {
     <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
     <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
 
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
     bar { x: Int -> x + 1}
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt
index 6ba859b70fb..e97fdd3c825 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt
@@ -4,8 +4,8 @@ package aa
 fun <T, R> foo(block: (T)-> R) = block
 
 fun test1() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
-        <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->  // here we have 'cannot infer parameter type' error
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->  // here we have 'cannot infer parameter type' error
         43
     }
 }
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt
index 61c1b5b6ad0..7bae629094a 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt
@@ -6,5 +6,5 @@ class X
 operator fun <T> X.component1(): T = TODO()
 
 fun test() {
-    val (<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>y<!>) = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>
+    val (y) = <!NI;COMPONENT_FUNCTION_MISSING, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt
index 001a1300acc..bf07e2b5f72 100644
--- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt
+++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt
@@ -4,6 +4,6 @@ class X
 operator fun <T> X.iterator(): Iterable<T> = TODO()
 
 fun test() {
-    for (i in <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>) {
+    for (i in <!NI;ITERATOR_MISSING, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>) {
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt
index 370007423b0..e10a80675fc 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt
+++ b/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt
@@ -6,7 +6,7 @@ interface A
 fun <T> emptyList(): List<T> = throw Exception()
 
 fun test1() {
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 }
 
 //--------------
@@ -14,7 +14,7 @@ fun test1() {
 fun <T: A> emptyListOfA(): List<T> = throw Exception()
 
 fun test2() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyListOfA<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyListOfA<!>()
 }
 
 //--------------
@@ -22,7 +22,7 @@ fun test2() {
 fun <T: A, R: T> emptyStrangeMap(): Map<T, R> = throw Exception()
 
 fun test3() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
 }
 
 //--------------
diff --git a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt
index f68063bc7c3..da716cf468c 100644
--- a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt
+++ b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt
@@ -5,6 +5,6 @@ class Outer {
 }
 
 fun nested() = Outer.Nested<Int>()
-fun noArguments() = Outer.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Nested<!>()
+fun noArguments() = Outer.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Nested<!>()
 fun noArgumentsExpectedType(): Outer.Nested<String> = Outer.Nested()
 fun manyArguments() = Outer.Nested<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String, Int><!>()
diff --git a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.ni.txt b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.ni.txt
index 407fc3d2c41..3af7e9b58f1 100644
--- a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.ni.txt
+++ b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.ni.txt
@@ -1,8 +1,8 @@
 package
 
-public fun manyArguments(): Outer.Nested<kotlin.Any?>
+public fun manyArguments(): Outer.Nested<???>
 public fun nested(): Outer.Nested<kotlin.Int>
-public fun noArguments(): Outer.Nested<kotlin.Any?>
+public fun noArguments(): Outer.Nested<???>
 public fun noArgumentsExpectedType(): Outer.Nested<kotlin.String>
 
 public final class Outer {
diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt
index f092f6d8aeb..a1501124a88 100644
--- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt
+++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt
@@ -12,10 +12,10 @@ public class A<E> {
 // TODO: It's effectively impossible to perform super call to such constructor
 // if there is not enough information to infer corresponding arguments
 // May be we could add some special syntax for such arguments
-class B1(x: List<String>) : <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!><CharSequence>("", x)
+class B1(x: List<String>) : <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!><CharSequence><!>("", x)
 class B2(x: List<Int>) : <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>A<CharSequence>("", x)<!>
 
 class C : A<CharSequence> {
-    constructor(x: List<String>) : <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>super<!>("", x)
+    constructor(x: List<String>) : <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>super<!>("", x)
     constructor(x: List<Int>, y: Int) : <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>super<!>("", x)
 }
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt
index 5f1c225af12..cea319d6347 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt
@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
-val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>x<!> get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()
-val y get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
+val x get() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()
+val y get() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
 
 fun <E> foo(): E = null!!
 fun <E> bar(): List<E> = null!!
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.ni.txt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.ni.txt
index cc71a5d3a8d..53d40b1cdf9 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.ni.txt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.ni.txt
@@ -1,6 +1,6 @@
 package
 
-public val x: kotlin.Nothing
-public val y: kotlin.collections.List<kotlin.Nothing>
+public val x: ???
+public val y: kotlin.collections.List<???>
 public fun </*0*/ E> bar(): kotlin.collections.List<E>
 public fun </*0*/ E> foo(): E
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt
index d8e0f16d48a..fdaa7e1e5c0 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt
@@ -10,8 +10,8 @@ class A {
     val a get() = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
     val b get() = <!NI;DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>
 
-    val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>z1<!> get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
-    val z2 get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>l<!>(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)
+    val z1 get() = id(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
+    val z2 get() = l(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)
 
     val u get() = <!UNRESOLVED_REFERENCE!>field<!>
 }
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.ni.txt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.ni.txt
index ed4126242a5..da9b6ba8875 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.ni.txt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.ni.txt
@@ -10,8 +10,8 @@ public final class A {
     public final val b: [ERROR : Error function type]
     public final val u: [ERROR : Error function type]
     public final val y: [ERROR : Error function type]
-    public final val z1: kotlin.Nothing
-    public final val z2: kotlin.collections.List<kotlin.Nothing>
+    public final val z1: ???
+    public final val z2: kotlin.collections.List<???>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt
index ef910e36490..ebb83e878de 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt
@@ -8,8 +8,8 @@
 }<!>
 
 // cantBeInferred.kt
-<!UNSUPPORTED_FEATURE!>val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>x1<!> get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()<!>
-<!UNSUPPORTED_FEATURE!>val y1 get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()<!>
+<!UNSUPPORTED_FEATURE!>val x1 get() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()<!>
+<!UNSUPPORTED_FEATURE!>val y1 get() = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()<!>
 
 fun <E> foo(): E = null!!
 fun <E> bar(): List<E> = null!!
diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.ni.txt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.ni.txt
index 5c6b388fc09..9dc8e7e025a 100644
--- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.ni.txt
+++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.ni.txt
@@ -2,12 +2,12 @@ package
 
 public val u: kotlin.String
 public val x: [ERROR : No type, no body]
-public val x1: kotlin.Nothing
+public val x1: ???
 public val x2: kotlin.String
 public var x3: kotlin.Int
 public val x4: [ERROR : Error function type]
 public val x5: kotlin.Nothing?
-public val y1: kotlin.collections.List<kotlin.Nothing>
+public val y1: kotlin.collections.List<???>
 public val y2: kotlin.collections.List<kotlin.Int>
 public val y5: kotlin.Nothing
 public val z2: kotlin.collections.List<kotlin.Int>
diff --git a/compiler/testData/diagnostics/tests/regressions/ea72837.kt b/compiler/testData/diagnostics/tests/regressions/ea72837.kt
index 91b6aac836c..d729cf38ef5 100644
--- a/compiler/testData/diagnostics/tests/regressions/ea72837.kt
+++ b/compiler/testData/diagnostics/tests/regressions/ea72837.kt
@@ -5,6 +5,6 @@ fun h(x: () -> Unit) = 1
 
 fun foo() {
     <!UNRESOLVED_REFERENCE!>f<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, SYNTAX!><!>)
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>g<!>(::<!SYNTAX!><!>)
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>g<!>(::<!SYNTAX!><!>)
     h(::<!SYNTAX!><!>)
 }
diff --git a/compiler/testData/diagnostics/tests/regressions/kt10843.kt b/compiler/testData/diagnostics/tests/regressions/kt10843.kt
index 02061727110..3992bd25473 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt10843.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt10843.kt
@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 // See EA-76890 / KT-10843: NPE during analysis
-fun lambda(x : Int?) = x?.<!FUNCTION_CALL_EXPECTED, NO_VALUE_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> <!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>l<!> {
+fun lambda(x : Int?) = x?.<!FUNCTION_CALL_EXPECTED, NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>l<!> {
     <!OI;CANNOT_INFER_PARAMETER_TYPE!>y<!> ->
     if (<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!> <!NI;UNREACHABLE_CODE!><!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0<!>) <!NI;UNREACHABLE_CODE!>return<!UNRESOLVED_REFERENCE!>@l<!> x<!>
     <!NI;UNREACHABLE_CODE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
diff --git a/compiler/testData/diagnostics/tests/regressions/kt10843.ni.txt b/compiler/testData/diagnostics/tests/regressions/kt10843.ni.txt
index 7a788993116..13a7c7da10b 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt10843.ni.txt
+++ b/compiler/testData/diagnostics/tests/regressions/kt10843.ni.txt
@@ -1,3 +1,3 @@
 package
 
-public fun lambda(/*0*/ x: kotlin.Int?): [ERROR : Error function type]
+public fun lambda(/*0*/ x: kotlin.Int?): [ERROR : <ERROR FUNCTION RETURN TYPE>]
diff --git a/compiler/testData/diagnostics/tests/regressions/kt353.kt b/compiler/testData/diagnostics/tests/regressions/kt353.kt
index 3a1fa33a319..89c5df433c1 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt353.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt353.kt
@@ -7,13 +7,13 @@ interface A {
 
 fun foo(a: A) {
     val <!UNUSED_VARIABLE!>g<!> : () -> Unit = {
-        a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>gen<!>()  //it works: Unit is derived
+        a.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>()  //it works: Unit is derived
     }
 
     val <!UNUSED_VARIABLE!>u<!>: Unit = a.gen() // Unit should be inferred
 
     if (true) {
-        a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
+        a.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
     }
 
     val <!UNUSED_VARIABLE!>b<!> : () -> Unit = {
@@ -29,5 +29,5 @@ fun foo(a: A) {
         a.gen()  //type mismatch, but Int can be derived
     }
 
-    a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
+    a.<!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
 }
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt
index 7fe9f3471ea..7a9faa105ec 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt
@@ -25,4 +25,4 @@ val y7: B<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH
 val y8: B<String> = B("")
 
 val y9 = B(1)
-val y10 = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>B<!>("")
+val y10 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>B<!>("")
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.ni.txt b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.ni.txt
index 01b8fad31a2..18da66c17a4 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.ni.txt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.ni.txt
@@ -4,7 +4,7 @@ public val x1: A
 public val x2: A
 public val x3: A
 public val y1: B<kotlin.Int>
-public val y10: B<kotlin.Any?>
+public val y10: B<???>
 public val y2: B<kotlin.Int>
 public val y3: B<kotlin.Int>
 public val y4: B<kotlin.Int>
diff --git a/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt b/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt
index bf45435bb16..2f1e47710b2 100644
--- a/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt
+++ b/compiler/testData/diagnostics/tests/typeParameters/implicitNothingAsTypeParameterNI.kt
@@ -11,39 +11,39 @@ fun <T>test_5(): List<T> = 10 <!CAST_NEVER_SUCCEEDS!>as<!> List<T>
 fun <K, V>test_6(): Map<K, V> = 10 <!CAST_NEVER_SUCCEEDS!>as<!> Map<K, V>
 
 fun case_1() {
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_5<!>()
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_6<!>()
-    val <!UNUSED_VARIABLE!>x<!> = <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_6<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_5<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_6<!>()
+    val <!UNUSED_VARIABLE!>x<!> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_6<!>()
 }
 
 fun case_2() {
-    test_1 { null!! }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_1<!> { null!! }
 }
 
 fun case_3() {
-    test_2 { null!! }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_2<!> { null!! }
 }
 
 fun case_4() {
-    test_3 { null!! }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_3<!> { null!! }
 }
 
 fun case_5() {
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_4<!> { null!! }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_4<!> { null!! }
 }
 
 fun case_6() {
-    test_1 { throw Exception() }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_1<!> { throw <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Exception<!>() }
 }
 
 fun case_7() {
-    test_2 { throw Exception() }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_2<!> { throw Exception() }
 }
 
 fun case_8() {
-    test_3 { throw Exception() }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_3<!> { throw <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Exception<!>() }
 }
 
 fun case_9() {
-    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_4<!> { throw Exception() }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test_4<!> { throw <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Exception<!>() }
 }
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt
index 583629c8e44..46bbc07fa6a 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt
@@ -11,5 +11,5 @@ typealias CT<T> = C<T>
 val test1 = <!OI;EXPANDED_TYPE_CANNOT_BE_CONSTRUCTED!>CStar()<!>
 val test2 = <!OI;EXPANDED_TYPE_CANNOT_BE_CONSTRUCTED!>CIn()<!>
 val test3 = <!OI;EXPANDED_TYPE_CANNOT_BE_CONSTRUCTED!>COut()<!>
-val test4 = CT<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+val test4 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>CT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
 val test5 = CT<CT<*>>()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.ni.txt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.ni.txt
index ee02dcb2600..8214d295a05 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.ni.txt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.ni.txt
@@ -3,7 +3,7 @@ package
 public val test0: N<kotlin.Int> /* = Num<kotlin.Int> */
 public val test1: N<kotlin.String> /* = Num<kotlin.String> */
 public val test2: C<kotlin.Int> /* = Cons<kotlin.Int> */
-public val test3: CC<kotlin.Any?> /* = Cons<Cons<kotlin.Any?>> */
+public val test3: CC<???> /* = Cons<Cons<???>> */
 public val test4: CC<kotlin.Int> /* = Cons<Cons<kotlin.Int>> */
 public val test5: PL<kotlin.Int> /* = Pair<kotlin.Int, kotlin.collections.List<kotlin.Int>> */
 public fun testProjections1(/*0*/ x: Pair<in kotlin.Int, out kotlin.String>): Foo<out kotlin.String>
diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt
index 376d408b644..0985a25df25 100644
--- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt
+++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt
@@ -5,4 +5,4 @@ class Cons<T : Number>(val head: T, val tail: Cons<T>?)
 typealias C<T> = Cons<T>
 
 val test1 = C(1, C(2, null))
-val test2 = C(1, <!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>C<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>""<!>, null)<!>)
+val test2 = C(1, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>C<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>""<!>, null)<!>)
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt
index 699aa5d399a..c19433676f1 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt
@@ -9,26 +9,26 @@ class Controller<T> {
 
 fun <S> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 
-val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test1<!> = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+val test1 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
     apply {
-        yield(<!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>)
+        yield(4)
     }
 }
 
-val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test2<!> = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
-    yield(<!NI;TYPE_MISMATCH!>B<!>)
+val test2 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield(B)
     apply {
-        yield(<!NI;TYPE_MISMATCH!>C<!>)
+        yield(C)
     }
 }
 
-val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test3<!> = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+val test3 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
     this.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> {
-        yield(<!NI;TYPE_MISMATCH!>B<!>)
+        yield(B)
     }
 
     apply {
-        yield(<!NI;TYPE_MISMATCH!>C<!>)
+        yield(C)
     }
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.ni.txt
index 4f73c8e8154..861d69dbc6a 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.ni.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.ni.txt
@@ -1,8 +1,8 @@
 package
 
-public val test1: kotlin.Nothing
-public val test2: kotlin.Nothing
-public val test3: kotlin.Nothing
+public val test1: ???
+public val test2: ???
+public val test3: ???
 public fun </*0*/ S> generate(/*0*/ g: suspend Controller<S>.() -> kotlin.Unit): S
 
 public interface A {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt
index 1f7cb3dc018..7aafbff5bdd 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt
@@ -29,7 +29,7 @@ val test1 = generate {
     baseExtension()
 }
 
-val test2 = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+val test2 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
     baseExtension()
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt
index c92b6c2b283..3f73c93a76d 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt
@@ -28,7 +28,7 @@ val test1 = generate {
     yield("foo")
 }
 
-val test2 = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+val test2 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
     starBase()
 }
 
@@ -47,6 +47,6 @@ val test5 = generateSpecific {
     stringBase()
 }
 
-val test6 = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generateSpecific<!> {
+val test6 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generateSpecific<!> {
     stringBase()
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt
index 2a1ad52c01d..dfffb034b7a 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt
@@ -18,8 +18,8 @@ val member = build {
     add(42)
 }
 
-val memberWithoutAnn = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
-    <!ILLEGAL_SUSPEND_FUNCTION_CALL!>add<!>(<!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)
+val memberWithoutAnn = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
+    <!ILLEGAL_SUSPEND_FUNCTION_CALL!>add<!>(42)
 }
 
 val extension = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.ni.txt
index 97b528581b6..36443636f61 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.ni.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.ni.txt
@@ -2,7 +2,7 @@ package
 
 public val extension: kotlin.collections.List<kotlin.String>
 public val member: kotlin.collections.List<kotlin.Int>
-public val memberWithoutAnn: kotlin.collections.List<kotlin.Nothing>
+public val memberWithoutAnn: kotlin.collections.List<???>
 public val safeExtension: kotlin.collections.List<kotlin.String>
 public fun </*0*/ S> build(/*0*/ g: suspend Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
 public fun </*0*/ S> wrongBuild(/*0*/ g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt
index 1c26ac1eb46..0df46524f9c 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt
@@ -3,7 +3,7 @@
 
 suspend fun wrapUp2() {
     withContext<Unit> {
-        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>other<!>()
+        <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>other<!>()
     }
 }
 suspend fun <T> withContext(block: suspend () -> T) {}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt
index b9fc0a49c70..a5f83cb7109 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt
@@ -18,7 +18,7 @@ suspend fun <S> GenericController<List<S>>.yieldGenerate(g: suspend GenericContr
 
 val test1 = generate {
     // TODO: KT-15185
-    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR, OI;TYPE_MISMATCH!>yieldGenerate<!> {
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR, OI;TYPE_MISMATCH!>yieldGenerate<!> {
         yield(4)
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.ni.txt
index 22b34c1f8db..18d72d5c225 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.ni.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.ni.txt
@@ -1,6 +1,6 @@
 package
 
-public val test1: kotlin.collections.List<kotlin.collections.List<kotlin.Any?>>
+public val test1: kotlin.collections.List<kotlin.collections.List<???>>
 public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>
 @kotlin.BuilderInference public suspend fun </*0*/ S> GenericController<kotlin.collections.List<S>>.yieldGenerate(/*0*/ g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.Unit
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt
index c14299a97ad..4b299877c99 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt
@@ -25,8 +25,8 @@ val member = build {
     add(42)
 }
 
-val memberWithoutAnn = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
-    add(<!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)
+val memberWithoutAnn = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>wrongBuild<!> {
+    add(42)
 }
 
 val extension = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>build<!> {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.ni.txt
index 25ef4449a8d..2c2293e9996 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.ni.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.ni.txt
@@ -2,7 +2,7 @@ package
 
 public val extension: kotlin.collections.List<kotlin.String>
 public val member: kotlin.collections.List<kotlin.Int>
-public val memberWithoutAnn: kotlin.collections.List<kotlin.Nothing>
+public val memberWithoutAnn: kotlin.collections.List<???>
 public val safeExtension: kotlin.collections.List<kotlin.String>
 public fun </*0*/ S> build(/*0*/ @kotlin.BuilderInference g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
 public fun </*0*/ S> wrongBuild(/*0*/ g: Builder<S>.() -> kotlin.Unit): kotlin.collections.List<S>
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt
index 76e51ac080c..4cb4d3a2642 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt
@@ -15,7 +15,7 @@ fun <S> generate(@BuilderInference g: suspend Controller<S>.() -> Unit): S = TOD
 
 class A
 
-val test1 = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+val test1 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
     yield(<!NO_COMPANION_OBJECT!>A<!>)
 }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt
index fad4ffce826..78b722505fc 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt
@@ -8,6 +8,6 @@ class Controller<T : Number> {
 
 fun <S : Number> generate(g: suspend Controller<S>.() -> Unit): S = TODO()
 
-val test = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
-    yield(<!NI;TYPE_MISMATCH!>"foo"<!>)
+val test = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield("foo")
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.ni.txt
index a832994fa5f..c2415d62369 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.ni.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.ni.txt
@@ -1,6 +1,6 @@
 package
 
-public val test: kotlin.Number
+public val test: ???
 public fun </*0*/ S : kotlin.Number> generate(/*0*/ g: suspend Controller<S>.() -> kotlin.Unit): S
 
 public final class Controller</*0*/ T : kotlin.Number> {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt
index 12fdae2ff77..d085841f48e 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt
@@ -8,8 +8,8 @@ class GenericController<T> {
 
 fun <S> generate(g: suspend GenericController<S>.(S) -> Unit): S = TODO()
 
-val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test1<!> = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
-    yield(<!NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>)
+val test1 = <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>generate<!> {
+    yield(4)
 }
 
 val test2 = generate<Int> {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.ni.txt
index 878c3d6ac6c..a052cb2fec4 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.ni.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.ni.txt
@@ -1,6 +1,6 @@
 package
 
-public val test1: kotlin.Nothing
+public val test1: ???
 public val test2: kotlin.Int
 public val test3: kotlin.Int
 public fun </*0*/ S> generate(/*0*/ g: suspend GenericController<S>.(S) -> kotlin.Unit): S
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.kt
index c2cbf5446ef..625b84328f5 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.kt
@@ -5,13 +5,13 @@
 import kotlin.experimental.ExperimentalTypeInference
 
 fun test1() {
-    sequence {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>sequence<!> {
         val a: Array<Int> = arrayOf(1, 2, 3)
         val b = arrayOf(1, 2, 3)
     }
 }
 
-fun test2() = sequence { arrayOf(1, 2, 3) }
+fun test2() = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>sequence<!> { arrayOf(1, 2, 3) }
 
 
 class Foo<T>
@@ -23,11 +23,11 @@ fun <T> f2(@BuilderInference f: Foo<T>.() -> Unit) {
 }
 
 fun test3() {
-    f1 {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f1<!> {
         val a: Array<Int> = arrayOf(1, 2, 3)
     }
 
-    f2 {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f2<!> {
         val a: Array<Int> = arrayOf(1, 2, 3)
     }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.txt
index 8aa658f413d..e529389a5a3 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.txt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.txt
@@ -3,7 +3,7 @@ package
 public fun </*0*/ T> f1(/*0*/ f: Foo<T>.() -> kotlin.Unit): kotlin.Unit
 @kotlin.UseExperimental(markerClass = {kotlin.experimental.ExperimentalTypeInference::class}) public fun </*0*/ T> f2(/*0*/ @kotlin.BuilderInference f: Foo<T>.() -> kotlin.Unit): kotlin.Unit
 public fun test1(): kotlin.Unit
-public fun test2(): kotlin.sequences.Sequence<kotlin.Any?>
+public fun test2(): [ERROR : Error function type]
 public fun test3(): kotlin.Unit
 
 public final class Foo</*0*/ T> {
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
index 4386d8bf28d..0466fc0c4cb 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
@@ -31,22 +31,22 @@ fun foo() {
     genericBuilder<Int> { <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
 
     val y = { 1 }
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>genericBuilder<!>(<!TYPE_MISMATCH!>y<!>)
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>genericBuilder<!>(<!TYPE_MISMATCH!>y<!>)
 
-    <!NI;UNREACHABLE_CODE!>unitBuilder {}<!>
-    <!NI;UNREACHABLE_CODE!>unitBuilder { <!OI;UNUSED_EXPRESSION!>1<!> }<!>
-    <!NI;UNREACHABLE_CODE!>unitBuilder({})<!>
-    <!NI;UNREACHABLE_CODE!>unitBuilder({ <!OI;UNUSED_EXPRESSION!>1<!> })<!>
+    unitBuilder {}
+    unitBuilder { <!UNUSED_EXPRESSION!>1<!> }
+    unitBuilder({})
+    unitBuilder({ <!UNUSED_EXPRESSION!>1<!> })
 
-    <!NI;UNREACHABLE_CODE!>manyArgumentsBuilder({}, { "" }) { 1 }<!>
+    manyArgumentsBuilder({}, { "" }) { 1 }
 
-    <!NI;UNREACHABLE_CODE!>val s: String = manyArgumentsBuilder({}, { "" }) { 1 }<!>
+    val s: String = manyArgumentsBuilder({}, { "" }) { 1 }
 
-    <!NI;UNREACHABLE_CODE!>manyArgumentsBuilder<String>({}, { "" }, { 1 })<!>
-    <!NI;UNREACHABLE_CODE!>manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })<!>
+    manyArgumentsBuilder<String>({}, { "" }, { 1 })
+    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
 
-    <!NI;UNREACHABLE_CODE!>severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
+    severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
         x checkType { _<String>() }
         y checkType { _<Int>() }
-    }<!>
+    }
 }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt
index b5618b01cfe..b46a6e56057 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt
@@ -13,7 +13,7 @@ fun <T> test3(t1: @kotlin.internal.NoInfer T): T = t1
 fun usage() {
     <!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>test1<!>(1, <!TYPE_MISMATCH!>"312"<!>)
     <!OI;TYPE_MISMATCH!>1<!>.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>test2<!>("")
-    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test3<!>("")
+    <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test3<!>("")
 }
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.kt
index fdbad6d3278..dcbe4462eee 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/1.kt
@@ -265,14 +265,14 @@ fun case_16() {
 
     if (<!DEBUG_INFO_CONSTANT!>x<!> != <!USELESS_IS_CHECK!><!USELESS_IS_CHECK!><!USELESS_IS_CHECK!><!USELESS_IS_CHECK!>null !is Boolean !is Boolean<!> !is Boolean<!> !is Boolean<!> !is Boolean<!>) {
         <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableNothing /* = kotlin.Nothing? */")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableNothing /* = kotlin.Nothing? */")!>x<!><!UNSAFE_CALL!>.<!>java
+        <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableNothing /* = kotlin.Nothing? */")!>x<!><!UNSAFE_CALL!>.<!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>java<!>
     }
 }
 
 // TESTCASE NUMBER: 17
 val case_17 = if (nullableIntProperty == null == true == false) 0 else {
     <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>nullableIntProperty<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>nullableIntProperty<!><!UNSAFE_CALL!>.<!>java
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>nullableIntProperty<!><!UNSAFE_CALL!>.<!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>java<!>
 }
 
 //TESTCASE NUMBER: 18
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/22.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/22.kt
index 9380c05fd39..3efb6b9d235 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/22.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/22.kt
@@ -176,7 +176,7 @@ fun case_12(x: Int?) {
 
     val y: Int
     while (true) {
-        <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>break<!UNREACHABLE_CODE!>[x!!]<!><!>
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>break<!UNREACHABLE_CODE!>[x!!]<!><!>
     }
 
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int & kotlin.Int?")!>x<!>
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.kt
index e6ccb7a8f21..9839fd0df46 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.kt
@@ -1304,13 +1304,9 @@ open class Case29(a: Int?, val b: Float?, private val c: Unit?, protected val d:
         s = null
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
         <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>this.s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>this.s<!>
     }
 
@@ -2352,13 +2348,9 @@ sealed class Case30(a: Int?, val b: Float?, private val c: Unit?, protected val
         s = null
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
         <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>this.s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>this.s<!>
     }
 
@@ -3401,13 +3393,9 @@ enum class Case31(a: Int?, val b: Float?, private val c: Unit?, protected val d:
         s = null
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
         <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>this.s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>this.s<!>
     }
 
@@ -4053,13 +4041,9 @@ object Case32 {
         s = null
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
         <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>s<!>
-        if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>this.s<!>.java
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any? & kotlin.Nothing")!>this.s<!>
     }
 
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.kt
index 137eb3da727..64e9665b951 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/6.kt
@@ -716,7 +716,6 @@ fun case_36(x: Any) {
 
     if (x == <!DEBUG_INFO_CONSTANT!>z<!>) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Nothing")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>x<!>.<!UNREACHABLE_CODE!>java<!>
     }
 }
 
@@ -735,7 +734,6 @@ fun case_38() {
     if (Object.prop_2 != <!DEBUG_INFO_CONSTANT!>z<!>)
     else {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing & kotlin.Number")!>Object.prop_2<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>Object.prop_2<!>.<!UNREACHABLE_CODE!>java<!>
     }
 }
 
@@ -990,7 +988,6 @@ fun case_57(a: (() -> Unit)) {
 
     if (a == <!DEBUG_INFO_CONSTANT!>z<!>) {
         <!DEBUG_INFO_EXPRESSION_TYPE("() -> kotlin.Unit & kotlin.Nothing")!>a<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("() -> kotlin.Unit & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>a<!>.<!UNREACHABLE_CODE!>java<!>
     }
 }
 
@@ -1001,7 +998,6 @@ fun case_58(a: ((Float) -> Int?)?, b: Float?, z: Nothing?) {
         <!DEBUG_INFO_CONSTANT, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Nothing?")!>b<!>
         if (<!DEBUG_INFO_CONSTANT!>a<!> != <!DEBUG_INFO_CONSTANT!>z<!>) {
             <!DEBUG_INFO_EXPRESSION_TYPE("((kotlin.Float) -> kotlin.Int?)? & (kotlin.Float) -> kotlin.Int? & kotlin.Nothing")!>a<!>
-            <!DEBUG_INFO_EXPRESSION_TYPE("((kotlin.Float) -> kotlin.Int?)? & kotlin.Nothing"), DEBUG_INFO_SMARTCAST!>a<!>.<!UNREACHABLE_CODE!>java<!>
         }
     }
 }