[NI] Update test data for diagnostic tests

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

@@ -7,16 +7,16 @@ fun <T> id(x: T): T = x
 fun <T> baz(x: T, y: T): T = TODO()
 
 fun test() {
-    val x1: (Int) -> Unit = id(id(::foo))
+    <!NI;UNREACHABLE_CODE!>val x1: (Int) -> Unit = id(<!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)<!NI;UNREACHABLE_CODE!>)<!>
-    val x2: (Int) -> Unit = baz(id(::foo), ::foo)
+    <!NI;UNREACHABLE_CODE!>val x2: (Int) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), ::foo)<!>
-    val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
+    <!NI;UNREACHABLE_CODE!>val x3: (Int) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
+    <!NI;UNREACHABLE_CODE!>val x4: (String) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    val x5: (Double) -> Unit = baz(id(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>), id(id(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)))
+    <!NI;UNREACHABLE_CODE!>val x5: (Double) -> Unit = baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;NONE_APPLICABLE!>foo<!>)))<!>
 
 
-    id<(Int) -> Unit>(id(id(::foo)))
+    <!NI;UNREACHABLE_CODE!>id<(Int) -> Unit>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    id(id<(Int) -> Unit>(::foo))
+    <!NI;UNREACHABLE_CODE!>id(id<(Int) -> Unit>(::foo))<!>
-    baz<(Int) -> Unit>(id(::foo), id(id(::foo)))
+    <!NI;UNREACHABLE_CODE!>baz<(Int) -> Unit>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
-    baz(id(::foo), id(id<(Int) -> Unit>(::foo)))
+    <!NI;UNREACHABLE_CODE!>baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), id(id<(Int) -> Unit>(::foo)))<!>
-    baz(id(::foo), id<(Int) -> Unit>(id(::foo)))
+    <!NI;UNREACHABLE_CODE!>baz(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>), id<(Int) -> Unit>(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!>(::<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)))<!>
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt

@@ -34,6 +34,6 @@ val bbb = null ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 val bbbb = ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>) ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 
 fun f(x : Long?): Long {
-    var a = x ?: (<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!> <!USELESS_ELVIS!>?: <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>fun() {}<!><!>)
+    var a = x ?: (<!OI;TYPE_MISMATCH!>fun() {}<!> <!USELESS_ELVIS!>?: <!OI;TYPE_MISMATCH!>fun() {}<!><!>)
-    return <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt

@@ -8,6 +8,6 @@ fun foo(): String {
 }
 fun bar(): String {
     val x = fn() ?: return ""
-    <!OI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>y<!> =<!> x<!UNNECESSARY_SAFE_CALL!>?.<!>let { throw Exception() } <!OI;UNREACHABLE_CODE, OI;USELESS_ELVIS!>?: "unreachable"<!>
+    <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>val <!NI;UNUSED_VARIABLE, OI;UNUSED_VARIABLE!>y<!> =<!> x<!UNNECESSARY_SAFE_CALL!>?.<!>let { throw Exception() } <!NI;UNREACHABLE_CODE, NI;USELESS_ELVIS, OI;UNREACHABLE_CODE, OI;USELESS_ELVIS!>?: "unreachable"<!>
-    <!OI;UNREACHABLE_CODE!>return y<!>
+    <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>return y<!>
 }

compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt

@@ -11,7 +11,7 @@ fun <T> bind(r: Option<T>): Option<T> {
         // Ideally we should infer Option<T> here (see KT-10896)
         (<!OI;TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>if<!> (true) <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>None()<!> else <!DEBUG_INFO_SMARTCAST!>r<!>) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><Option<T>>() }
         // Works correctly
-        if (true) None() else <!NI;DEBUG_INFO_SMARTCAST!>r<!>
+        if (true) None() else r
     }
     else r
 }
@@ -25,7 +25,7 @@ fun <T> bind2(r: Option<T>): Option<T> {
 }
 
 fun <T, R> bind3(r: Option<T>): Option<T> {
-    return <!NI;TYPE_MISMATCH!>if (r is Some) {
+    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (r is Some) {
         // Diagnoses an error correctly
         if (true) <!OI;TYPE_MISMATCH!>None<R>()<!> else r
     }
@@ -36,7 +36,7 @@ fun <T> bindWhen(r: Option<T>): Option<T> {
     return when (r) {
         is Some -> {
             // Works correctly
-            if (true) None() else <!NI;DEBUG_INFO_SMARTCAST!>r<!>
+            if (true) None() else r
         }
         else -> r
     }

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt

@@ -108,7 +108,7 @@ fun testImplicitCoercion() {
     val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
     bar(<!NI;TYPE_MISMATCH!>if (true) {
-        <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
     }
         else {
         <!UNUSED_VALUE!>z =<!> 342

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt

@@ -6,6 +6,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>x<!> else x<!>)
+    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>x<!> else x<!>)
     if (x != null) bar(x + x/(x-x*x))
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt

@@ -4,7 +4,7 @@ fun bar(x: Int) = x + 1
 fun f1(x: Int?) {
     bar(<!TYPE_MISMATCH!>x<!>)
     if (x != null) bar(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
-    if (x == null) <!OI;UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
+    if (x == null) <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>bar(<!><!ALWAYS_NULL!>x<!>!!<!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>)<!>
 }
 
 fun f2(x: Int?) {    

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

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

compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt

@@ -19,8 +19,8 @@ fun test(i: Int?) {
 
     foo(<!REDUNDANT_LABEL_WARNING!>l4@<!> <!TYPE_MISMATCH!>""<!>)
     foo((<!TYPE_MISMATCH!>""<!>))
-    foo(checkSubtype<Int>(<!TYPE_MISMATCH!>""<!>))
+    foo(checkSubtype<Int>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>))
-    foo(<!TYPE_MISMATCH!>checkSubtype<Long>(<!TYPE_MISMATCH!>""<!>)<!>)
+    foo(<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>checkSubtype<Long>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>)<!>)
     
     use(a, b, c, d)
 }

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

@@ -12,7 +12,7 @@ fun test(a: (Int) -> Int) {
 }
 
 fun test2(a: () -> List<Int>) {
-    test2(fun () = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>())
+    test2(fun () = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>())
 }
 
 val a: (Int) -> Unit = fun(x) { checkSubtype<Int>(x) }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt

@@ -30,7 +30,7 @@ fun bar(aInstance: A, bInstance: B) {
         d checkType { _<Short>() }
     }
 
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bInstance) {
+    <!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) ->
         <!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>() }

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

@@ -24,7 +24,7 @@ fun foo(x: MC<out Open>) {
     x.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>mc<Derived>()<!>)
     x.addAllMC(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>mc<Derived>()<!>)
 
-    x.addAll(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>c<!>())
+    x.addAll(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>c<!>())
     x.addAll(c<Nothing>())
 
     x.<!OI;MEMBER_PROJECTED_OUT!>addAllInv<!>(<!NI;TYPE_MISMATCH!>mc<Open>()<!>)

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

@@ -17,7 +17,7 @@ fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
         <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!>
     }
     a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
-    a.bar { <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>() }
+    a.bar { <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>() }
     a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.<!NI;TYPE_MISMATCH!>id()<!><!> }
 
     a.foo {

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

@@ -14,12 +14,12 @@ class A<T> {
 
 fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
     a.<!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo1<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Out<CharSequence>()<!>)
-    a.foo1<<!UPPER_BOUND_VIOLATED!>Out<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Out()<!>)
+    a.foo1<<!UPPER_BOUND_VIOLATED!>Out<CharSequence><!>>(<!NI;TYPE_MISMATCH!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>()<!>)
 
-    a.foo1(<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>())
+    a.foo1(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>())
     a.foo1(Out<Nothing>())
 
-    a.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
+    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_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.<!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>foo2<!>(<!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Inv<!>()<!>)
+    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_UPPER_BOUND_VIOLATED!>foo2<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Inv<CharSequence>()<!>)
     b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!NI;TYPE_MISMATCH!>Inv()<!>)
 

compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt

@@ -6,7 +6,7 @@ inline fun <reified T> f(): T = throw UnsupportedOperationException()
 fun <T> id(p: T): T = p
 
 fun <A> main() {
-    <!NI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f<!>()
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, 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<!>>()<!>
@@ -14,5 +14,5 @@ fun <A> main() {
     <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>b<!>: Int = f()<!>
     <!NI;UNREACHABLE_CODE!>f<Int>()<!>
 
-    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!NI;TYPE_PARAMETER_AS_REIFIED, TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
+    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>с<!>: A = id(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, OI;TYPE_PARAMETER_AS_REIFIED!>f<!>())<!>
 }

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<!> =<!> <!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>infer<!>(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>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<!>)
 }
 
 fun sum(<!UNUSED_PARAMETER!>a<!> : IntArray) : Int {

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() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMap<!>(
+    <!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<!>(
 <!SYNTAX!><!>}
 

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

@@ -7,6 +7,6 @@ fun foo1() {
     <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
 }
 
-val n : Nothing = null.<!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>sure<!>()
+val n : Nothing = null.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>sure<!>()
 
 fun <T : Any> T?.sure() : T = this!!

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")
-    materialize()
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>materialize<!>()
 }

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

@@ -8,6 +8,6 @@ fun a(): Unit = run {
 
 fun b(): Unit = run {
     run {
-        <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
+        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
     }
 }

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<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!NI;UNREACHABLE_CODE!>return@l<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }

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

@@ -11,7 +11,7 @@ fun a(): Unit = run {
 
 fun b(): Unit = run {
     // Ok, expected type is applied
-    materialize()
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>materialize<!>()
 }
 
 fun c(): Unit = run {
@@ -19,13 +19,13 @@ fun c(): Unit = 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
-        <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
 
 fun d(): Unit = run outer@{
     run inner@{
-        <!NI;UNREACHABLE_CODE!>return@inner<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!NI;UNREACHABLE_CODE!>return@inner<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
     }
 }
 

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

@@ -9,8 +9,8 @@ inline fun <reified T> foo2(f: (T) -> Unit): Foo<T> = Foo()
 
 fun test1() {
     val f1: Foo<out Int> = foo1 { it checkType { _<Int>() } }
-    val f2: Foo<in Nothing> = <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>foo1<!> { it <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
+    val f2: Foo<in Nothing> = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>foo1<!> { it <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
 
     val f3: Foo<out Int> = foo2 { it checkType { _<Int>() } }
-    val f4: Foo<in Nothing> = <!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo2<!> { it <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
+    val f4: Foo<in Nothing> = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo2<!> { it <!UNREACHABLE_CODE!><!OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>checkType<!> { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
 }

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

@@ -9,13 +9,13 @@ fun testLambda() {
         { it -> <!DEBUG_INFO_SMARTCAST!>x<!> + it }
     }
 
-    val twoLambda: (Int) -> Int = myRun {
+    val twoLambda: (Int) -> Int = <!TYPE_MISMATCH!>myRun {
         val x: Int = 1
-        run {
+        <!TYPE_MISMATCH!>run {
             val y: Int = 2
             { x + y }
-        }
+        }<!>
-    }
+    }<!>
 
 }
 

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 = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>plus<!>("") <!NI;USELESS_CAST!>as String<!>
+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<!>
 
 fun <T> T.bar() = this
 val barTest = "".bar() <!CAST_NEVER_SUCCEEDS!>as<!> Number

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

@@ -9,10 +9,10 @@ class A {
 
 fun <V> id(value: V) = value
 
-val asA = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+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 receiverParenthesized = (<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!NI;UNRESOLVED_REFERENCE, OI;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().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!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 correct1 = A().fooA() as A
 val correct2 = foo<A>().fooA() as A

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

@@ -7,7 +7,7 @@ fun <V> id(value: V) = value
 
 val asString = foo() as String
 
-val viaId = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>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, 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!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is 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!><!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<!>

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)
 
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
+    <!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<!>())
 }

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 =<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
+    <!NI;UNREACHABLE_CODE!>val t =<!> <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
 }

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

@@ -16,10 +16,10 @@ fun test1() {
 fun <T, R> bar(body: (R) -> T): T = fail()
 
 fun test2() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
+    <!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;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+    <!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<!>
     }<!>
 }
@@ -27,10 +27,10 @@ fun test2() {
 fun <T, R> baz(body: (List<R>) -> T): T = fail()
 
 fun test3() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
+    <!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;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+    <!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<!>
     }<!>
 }

compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt

@@ -24,7 +24,7 @@ fun test(z: Z) {
 operator fun <T> Z.plus(a: A<T>): A<T> = a
 
 fun test1(z: Z) {
-    id(z <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    <!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())<!>
@@ -56,7 +56,7 @@ fun test3(z: Z) {
 
 //'in' operation
 fun test4(collection: Collection<A<*>>) {
-    id(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>() in collection)
+    <!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)<!>
 }
 

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 <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar2<!>()<!>
-    fun <!NI;IMPLICIT_NOTHING_RETURN_TYPE!>bar3<!>() = id(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar3<!>()<!>)
+    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 <T> id(x: T) = x

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

@@ -4,7 +4,7 @@
 package a
 
 fun main() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {
 
     }
 }

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

@@ -3,5 +3,5 @@ fun <T, U> T.map(f: (T) -> U) = f(this)
 fun consume(<!UNUSED_PARAMETER!>s<!>: String) {}
 
 fun test() {
-    consume(1.map(::<!UNRESOLVED_REFERENCE!>foo<!>))
+    <!UNREACHABLE_CODE!>consume(<!>1.map(::<!UNRESOLVED_REFERENCE!>foo<!>)<!UNREACHABLE_CODE!>)<!>
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt

@@ -6,5 +6,5 @@ class X
 operator fun <T> X.component1(): T = TODO()
 
 fun test() {
-    val (y) = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>
+    val (<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>y<!>) = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>
 }

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 <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>) {
+    for (i in <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>) {
     }
 }

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

@@ -6,7 +6,7 @@ interface A
 fun <T> emptyList(): List<T> = throw Exception()
 
 fun test1() {
-    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+    <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 }
 
 //--------------

compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt

@@ -10,7 +10,7 @@ public class TestClass {
 fun run() {
     val testClass = TestClass()
     // inferred as `set<Nothing>()`, return type is Nothing!
-    testClass.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>set<!>("test", null)
+    testClass.set("test", null)
 
     // Should not be unreachable
     run()

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt

@@ -23,8 +23,8 @@ fun main() {
         foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
     } else {
         foo(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
-        <!OI;UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
+        <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>)<!>
-        <!OI;UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
+        <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
     }
 
     foo(<!DEBUG_INFO_SMARTCAST!>x<!>)

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt

@@ -7,18 +7,18 @@ fun <T> nullable(): T? = null
 fun <T> dependOn(x: T) = x
 
 fun test() {
-    takeNotNull(notNull()<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
+    <!NI;UNREACHABLE_CODE!>takeNotNull(<!><!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>notNull<!>()<!NI;UNREACHABLE_CODE!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)<!>
-    takeNotNull(nullable()!!)
+    <!NI;UNREACHABLE_CODE!>takeNotNull(<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>()!!)<!>
 
-    var x: String? = null
+    <!NI;UNREACHABLE_CODE!>var x: String? = null<!>
-    takeNotNull(dependOn(x)!!)
+    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(x)!!)<!>
-    takeNotNull(dependOn(dependOn(x))!!)
+    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x))!!)<!>
-    takeNotNull(dependOn(dependOn(x)!!))
+    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x)!!))<!>
-    takeNotNull(dependOn(dependOn(x!!)))
+    <!NI;UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x!!)))<!>
 
-    if (x != null) {
+    <!NI;UNREACHABLE_CODE!>if (x != null) {
         takeNotNull(dependOn(x)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         takeNotNull(dependOn(dependOn(x))<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         takeNotNull(dependOn(dependOn(x)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>))
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt

@@ -22,21 +22,21 @@ fun <T> nullable(): T? = null
 fun <T> dependOn(x: T) = x
 
 fun test() {
-    takeNotNull(notNull() ?: "")
+    <!UNREACHABLE_CODE!>takeNotNull(<!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>notNull<!>() <!UNREACHABLE_CODE!><!USELESS_ELVIS!>?: ""<!>)<!>
-    takeNotNull(nullable() ?: "")
+    <!UNREACHABLE_CODE!>takeNotNull(<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>() ?: "")<!>
 
-    val x: String? = null
+    <!UNREACHABLE_CODE!>val x: String? = null<!>
-    takeNotNull(dependOn(x) ?: "")
+    <!UNREACHABLE_CODE!>takeNotNull(dependOn(x) ?: "")<!>
-    takeNotNull(dependOn(dependOn(x)) ?: "")
+    <!UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x)) ?: "")<!>
-    takeNotNull(dependOn(dependOn(x as String)) <!USELESS_ELVIS!>?: ""<!>)
+    <!UNREACHABLE_CODE!>takeNotNull(dependOn(dependOn(x as String)) <!USELESS_ELVIS!>?: ""<!>)<!>
 
-    if (x != null) {
+    <!UNREACHABLE_CODE!>if (x != null) {
         takeNotNull(dependOn(x) <!USELESS_ELVIS!>?: ""<!>)
         takeNotNull(dependOn(dependOn(x)) <!USELESS_ELVIS!>?: ""<!>)
         takeNotNull(dependOn(dependOn(x) as? String) ?: "")
-    }
+    }<!>
 
-    takeNotNull(bar()!!)
+    <!UNREACHABLE_CODE!>takeNotNull(bar()!!)<!>
 }
 
 inline fun <reified T : Any> reifiedNull(): T? = null

compiler/testData/diagnostics/tests/overload/defaultParameters.kt

@@ -55,5 +55,5 @@ fun test() {
 
     withGenericDefaults("")
 
-    <!OI;UNREACHABLE_CODE!><!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(<!>null!!<!OI;UNREACHABLE_CODE!>)<!>
+    <!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!><!OVERLOAD_RESOLUTION_AMBIGUITY!>wrong<!>(<!>null!!<!NI;UNREACHABLE_CODE, OI;UNREACHABLE_CODE!>)<!>
 }

compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt

@@ -21,5 +21,5 @@ public class Element {
 import p.*
 
 fun test(v: Visitor<Nothing>, e: Element) {
-    e.accept(v, null)
+    e.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>accept<!>(v, null)
 }

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 fun test() {
-    take(nullable() ?: nullable() ?: "foo")
+    take(<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>() ?: <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>nullable<!>() ?: "foo")
 }
 
 fun <T> nullable(): T? = TODO()

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() = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()
+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() = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
+val y get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
 
 fun <E> foo(): E = null!!
 fun <E> bar(): List<E> = null!!

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() = id(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
+    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() = l(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)
+    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 u get() = <!UNRESOLVED_REFERENCE!>field<!>
 }

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt

@@ -8,8 +8,8 @@
 }<!>
 
 // cantBeInferred.kt
-<!UNSUPPORTED_FEATURE!>val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>x1<!> get() = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()<!>
+<!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() = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()<!>
+<!UNSUPPORTED_FEATURE!>val y1 get() = <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()<!>
 
 fun <E> foo(): E = null!!
 fun <E> bar(): List<E> = null!!

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

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

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

@@ -7,18 +7,18 @@ interface A {
 
 fun foo(a: A) {
     val <!UNUSED_VARIABLE!>g<!> : () -> Unit = {
-        a.gen()  //it works: Unit is derived
+        a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>gen<!>()  //it works: Unit is derived
     }
 
     val <!UNUSED_VARIABLE!>u<!>: Unit = a.gen() // Unit should be inferred
 
     if (true) {
-        a.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
+        a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
     }
 
     val <!UNUSED_VARIABLE!>b<!> : () -> Unit = {
         if (true) {
-            a.gen()  // unit can be inferred
+            a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>gen<!>()  // unit can be inferred
         }
         else {
             Unit
@@ -29,5 +29,5 @@ fun foo(a: A) {
         a.gen()  //type mismatch, but Int can be derived
     }
 
-    a.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
+    a.<!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>gen<!>() // Shouldn't work: no info for inference
 }

compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt

@@ -18,15 +18,15 @@ fun foo(i: Int, f: (Int)->Int) = f(i)
 fun <T> id(t: T) = t
 
 fun test() {
-    foo(1, id { x1 ->
+    <!UNREACHABLE_CODE!>foo(<!>1, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { x1 ->
-        foo(2, id { x2 ->
+        <!UNREACHABLE_CODE!>foo(<!>2, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x2<!> ->
-            foo(3, id { x3 ->
+            <!UNREACHABLE_CODE!>foo(<!>3, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x3<!> ->
-                foo(4, id { x4 ->
+                <!UNREACHABLE_CODE!>foo(<!>4, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x4<!> ->
-                    foo(5, id { x5 ->
+                    <!UNREACHABLE_CODE!>foo(<!>5, <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>id<!> { <!UNUSED_ANONYMOUS_PARAMETER!>x5<!> ->
-                        x1 + x2 + x3 + x4 + x5 + A.iii
+                        x1 <!UNREACHABLE_CODE!>+ x2 + x3 + x4 + x5 + A.iii<!>
-                    })
+                    }<!UNREACHABLE_CODE!>)<!>
-                })
+                }<!UNREACHABLE_CODE!>)<!>
-            })
+            }<!UNREACHABLE_CODE!>)<!>
-        })
+        }<!UNREACHABLE_CODE!>)<!>
-    })
+    }<!UNREACHABLE_CODE!>)<!>
 }

compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt

@@ -22,11 +22,11 @@ fun foo(i: Int, f: (Int) -> Int) = f(i)
 fun <T> id(t: T) = t
 
 fun test() {
-    <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(1, id(fun(x1: Int) =
+    foo(1, id(fun(x1: Int) =
-          <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(2, id(fun(x2: Int) =
+          foo(2, id(fun(x2: Int) =
-                <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(3, id(fun(x3: Int) =
+                foo(3, id(fun(x3: Int) =
-                      <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(4, id(fun(x4: Int) =
+                      foo(4, id(fun(x4: Int) =
-                            <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>(5, id(fun(x5: Int) =
+                            foo(5, id(fun(x5: Int) =
                                   x1 + x2 + x3 + x4 + x5 + A.iii
                             ))
                       ))

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

@@ -10,5 +10,5 @@ fun use() {
     // Write is AFTER
     <!DEBUG_INFO_SMARTCAST!>x<!>.hashCode()
     // x is nullable at the second argument
-    foo(bar { x = null }, x!!)
+    <!UNREACHABLE_CODE!>foo(<!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>bar<!> { x = null }, <!UNREACHABLE_CODE!>x!!)<!>
 }

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

@@ -10,5 +10,5 @@ fun use() {
     // Write to x is AFTER
     <!DEBUG_INFO_SMARTCAST!>x<!>.hashCode()
     // No smart cast should be here!
-    foo(bar { x = null }, <!SMARTCAST_IMPOSSIBLE!>x<!>.hashCode())
+    <!UNREACHABLE_CODE!>foo(<!><!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>bar<!> { x = null }, <!UNREACHABLE_CODE!><!SMARTCAST_IMPOSSIBLE!>x<!>.hashCode())<!>
 }

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

@@ -11,13 +11,13 @@ fun case_1() {
 }
 
 fun case_2() {
-    test_1 { null!! }
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_1<!> { null!! }
-    test_2 { null!! }
+    <!UNREACHABLE_CODE!>test_2 { null!! }<!>
 }
 
 fun case_3() {
-    test_1 { throw Exception() }
+    <!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>test_1<!> { throw Exception() }
-    test_2 { throw Exception() }
+    <!UNREACHABLE_CODE!>test_2 { throw Exception() }<!>
 }
 
 fun case_6() {
@@ -39,5 +39,5 @@ class Context<T>
 fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()
 
 fun <T> Any?.decodeOut(typeFrom: Context<out T>): T {
-    return this?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>decodeIn<!>(typeFrom) ?: <!UNRESOLVED_REFERENCE!>error<!>("")
+    return this?.<!IMPLICIT_NOTHING_AS_TYPE_PARAMETER, IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>decodeIn<!>(typeFrom) ?: <!UNRESOLVED_REFERENCE!>error<!>("")
 }

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

@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
-val test: Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (true) {
+val test: Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (true) {
     when (2) {
         1 -> 1
         else -> <!OI;NULL_FOR_NONNULL_TYPE!>null<!>

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

@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun test1(): Int {
-    val x: String = <!NI;TYPE_MISMATCH!>if (true) {
+    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (true) {
         when {
             true -> <!OI;TYPE_MISMATCH!>Any()<!>
             else -> <!OI;NULL_FOR_NONNULL_TYPE!>null<!>
@@ -10,7 +10,7 @@ fun test1(): Int {
 }
 
 fun test2(): Int {
-    val x: String = <!NI;TYPE_MISMATCH!>when {
+    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>when {
                         true -> <!OI;TYPE_MISMATCH!>Any()<!>
                         else -> null
                     } ?: return 0<!>