Relax rules about inferring to Nothing for special calls

#KT-37388 Fixed
 #KT-38427 Fixed
 #KT-39953 Fixed
 #KT-38899 Fixed

compiler/testData/diagnostics/tests/FunctionReturnTypes.kt

@@ -67,7 +67,7 @@ fun blockAndAndMismatch5() : Int {
     (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>) || (return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>false<!>)
 }
 fun blockReturnValueTypeMatch1() : Int {
-    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (1 > 2) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!><!>
+    return if (1 > 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> else <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch2() : Int {
     return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2) 1<!>
@@ -134,8 +134,8 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
         }
     }
     <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-fun nonBlockReturnIfEmptyIf(): Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (1 < 2) <!OI;TYPE_MISMATCH!>{}<!> else <!OI;TYPE_MISMATCH!>{}<!><!>
-fun nonBlockNoReturnIfUnitInOneBranch(): Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (1 < 2) <!OI;TYPE_MISMATCH!>{}<!> else 2<!>
+fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else <!TYPE_MISMATCH!>{}<!>
+fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <!TYPE_MISMATCH!>{}<!> else 2
 
 val a = <!RETURN_NOT_ALLOWED!>return<!> 1
 
@@ -146,14 +146,14 @@ fun illegalConstantBlock(): String {
     return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
 }
 fun illegalIfBody(): Int =
-        <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (1 < 2) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else { <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> }<!>
+        if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!NI;TYPE_MISMATCH!>{ <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!> }<!>
 fun illegalIfBlock(): Boolean {
     if (1 < 2)
         return false
     else { return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
 }
 fun illegalReturnIf(): Char {
-    return <!NI;TYPE_MISMATCH!>if (1 < 2) 'a' else { <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }<!>
+    return if (1 < 2) 'a' else <!NI;TYPE_MISMATCH!>{ <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }<!>
 }
 
 fun returnNothing(): Nothing {

compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt

@@ -23,7 +23,7 @@ class Test {
     val Int.c: Int get() = 42
 
     val test1: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
-    val test1a: () -> Right = a.b.c::foo
+    val test1a: () -> Right = a.<!NI;DEBUG_INFO_LEAKING_THIS!>b<!>.<!NI;DEBUG_INFO_LEAKING_THIS!>c<!>::foo
 
     val test2: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>?::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
 }

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

@@ -25,11 +25,11 @@ 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 if (r is Some) <!NI;TYPE_MISMATCH!>{
         // Diagnoses an error correctly
         if (true) <!OI;TYPE_MISMATCH!>None<R>()<!> else r
-    }
-    else r<!>
+    }<!>
+    else r
 }
 
 fun <T> bindWhen(r: Option<T>): Option<T> {

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

@@ -2,9 +2,9 @@
 package f
 
 fun test(a: Boolean, b: Boolean): Int {
-    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if(a) {
+    return if(a) {
         1
-    } else {
+    } else <!NI;TYPE_MISMATCH!>{
         <!OI;TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
             3
         }<!>

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

@@ -30,11 +30,11 @@ val testSafeCall4: String? = J.m[""]?.let { it.toString() }
 val testIf1: String = if (true) J.s else J.s
 val testIf2: String? = if (true) J.s else J.s
 
-val testIf3: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (true) <!OI;TYPE_MISMATCH!>J.m[""]<!> else <!OI;TYPE_MISMATCH!>J.m[""]<!><!>
+val testIf3: String = if (true) <!TYPE_MISMATCH!>J.m[""]<!> else <!TYPE_MISMATCH!>J.m[""]<!>
 val testIf4: String? = if (true) J.m[""] else J.m[""]
 
 val testWhen1: String = when { else -> J.s }
 val testWhen2: String? = when { else -> J.s }
 
-val testWhen3: String = <!NI;TYPE_MISMATCH!>when { else -> <!OI;TYPE_MISMATCH!>J.m[""]<!> }<!>
+val testWhen3: String = when { else -> <!TYPE_MISMATCH!>J.m[""]<!> }
 val testWhen4: String? = when { else -> J.m[""] }

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

@@ -14,15 +14,15 @@ fun foo() : Int {
 }
 
 fun bar() : Int =
-    <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>try {
+    try <!NI;TYPE_MISMATCH!>{
         <!OI;TYPE_MISMATCH!>doSmth()<!>
-    }
-    catch (e: Exception) {
+    }<!>
+    catch (e: Exception) <!NI;TYPE_MISMATCH!>{
         <!OI;TYPE_MISMATCH!>""<!>
-    }
+    }<!>
     finally {
         <!UNUSED_EXPRESSION!>""<!>
-    }<!>
+    }
 
 
 fun doSmth() {}

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

@@ -7,6 +7,6 @@ fun foo() {
 
     val <!UNUSED_VARIABLE!>a<!> = object {
         fun baz() = bar(if (x == null) 0 else <!DEBUG_INFO_SMARTCAST!>x<!>)
-        fun quux(): Int = <!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>x<!> else <!DEBUG_INFO_SMARTCAST!>x<!><!>
+        fun quux(): Int = if (x == null) <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> else <!DEBUG_INFO_SMARTCAST!>x<!>
     }
 }

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

@@ -9,7 +9,7 @@ fun foo(): Int {
     if (x != null) return x
     
     val y: Int? = null
-    if (y == null) return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>y<!> != null<!>) y else <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>y<!><!>
+    if (y == null) return if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>y<!> != null<!>) y else <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>
     
     val z: Int? = null
     if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z

compiler/testData/diagnostics/tests/exposed/inaccessibleType.kt

@@ -39,7 +39,7 @@ fun <T> listOf2(x1: T, x2: T): List<T> = null!!
 fun <T> arrayOf2(x1: T, x2: T): Array<T> = null!!
 
 fun test() {
-    val test1: Base = <!NI;INACCESSIBLE_TYPE!>if (true) d1 else d2<!>
+    val test1: Base = if (true) d1 else d2
 
     val test2 = <!INACCESSIBLE_TYPE!>if (true) d1 else d2<!>
 
@@ -48,10 +48,10 @@ fun test() {
         else -> d2
     }<!>
 
-    val test4: Base = <!NI;INACCESSIBLE_TYPE!>when {
+    val test4: Base = when {
         true -> d1
         else -> d2
-    }<!>
+    }
 
     val test5 = <!INACCESSIBLE_TYPE!>select(d1, d2)<!>
 

compiler/testData/diagnostics/tests/implicitIntersection.kt

@@ -10,13 +10,13 @@ interface C
 fun <!OI;IMPLICIT_INTERSECTION_TYPE!>foo<!>(b: B) = if (b is A && b is C) b else null
 
 // Ok: given explicitly
-fun gav(b: B): A? = if (b is A && b is C) <!OI;DEBUG_INFO_SMARTCAST!>b<!> else null
+fun gav(b: B): A? = if (b is A && b is C) <!DEBUG_INFO_SMARTCAST!>b<!> else null
 
 class My(b: B) {
     // Error!
     val <!OI;IMPLICIT_INTERSECTION_TYPE!>x<!> = if (b is A && b is C) b else null
     // Ok: given explicitly
-    val y: C? = if (b is A && b is C) <!OI;DEBUG_INFO_SMARTCAST!>b<!> else null
+    val y: C? = if (b is A && b is C) <!DEBUG_INFO_SMARTCAST!>b<!> else null
     // Error!
     fun <!OI;IMPLICIT_INTERSECTION_TYPE!>foo<!>(b: B) = if (b is A && b is C) b else null
 }

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

@@ -6,8 +6,8 @@ fun main() {
     val x1: String.() -> String = if (true) {{ this }} else {{ this }}
     val x2: String.() -> String = if (true) {{ -> this }} else {{ -> this }}
     val x3: () -> String = if (true) {{ -> "this" }} else {{ -> "this" }}
-    val x4: String.() -> String = if (true) {{ str: String -> "this" }} else {{ str: String -> "this" }}
-    val x41: String.(String) -> String = if (true) {{ str: String, str2: String -> "this" }} else {{ str: String, str2: String -> "this" }}
+    val x4: String.() -> String = if (true) <!TYPE_MISMATCH!>{{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str: String<!> -> "this" }}<!> else <!TYPE_MISMATCH!>{{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str: String<!> -> "this" }}<!>
+    val x41: String.(String) -> String = if (true) <!TYPE_MISMATCH!>{{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str: String, str2: String<!> -> "this" }}<!> else <!TYPE_MISMATCH!>{{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str: String, str2: String<!> -> "this" }}<!>
     val x42: String.(String) -> String = if (true) <!TYPE_MISMATCH!>{{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!><!> -> "this" }}<!> else <!TYPE_MISMATCH!>{{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str, <!CANNOT_INFER_PARAMETER_TYPE!>str2<!><!> -> "this" }}<!>
     val x5: String.() -> String = if (true) <!TYPE_MISMATCH!>{{ <!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str<!> -> "this" }}<!> else <!TYPE_MISMATCH!>{{ <!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str<!> -> "this" }}<!>
     val x6: String.() -> String = if (true) <!TYPE_MISMATCH!>{{ <!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>str<!> -> "this" }}<!> else {{ "this" }}

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

@@ -25,5 +25,5 @@ fun test(s: SelectorFor<State>): Double {
     val e = s { return p1 }
     e checkType { _<AbstractSelector<State, Nothing>>() }
 
-    <!UNREACHABLE_CODE!>return<!> null!!
+    <!OI;UNREACHABLE_CODE!>return<!> null!!
 }

compiler/testData/diagnostics/tests/inference/nothingType/kt32388.kt

@@ -2,7 +2,7 @@
 
 fun <A, B> Either<A, B>.recover(f: (A) -> B): Either<A, B> = when (this) {
     is Either.Left -> f(<!DEBUG_INFO_SMARTCAST!>this<!>.a).right()
-    is Either.Right -> <!NI;DEBUG_INFO_SMARTCAST!>this<!>
+    is Either.Right -> this
 }
 
 fun <A> A.right(): Either<Nothing, A> = Either.Right(this)

compiler/testData/diagnostics/tests/inference/nothingType/nullableExpectedTypeFromVariable.fir.kt

@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !LANGUAGE: +NewInference
+// WITH_RUNTIME
+
+class Foo<T> {
+    private fun append(map: MutableMap<String, T>, field: String, appendedValue: T?) {
+        if (appendedValue != null) {
+            var currentValue: T? = map[field]
+            currentValue = if (currentValue == null) {
+                appendedValue
+            } else {
+                or(currentValue, appendedValue)
+            }
+            map[field] = currentValue
+        }
+    }
+
+    fun or(left: T, right: T): T = left
+}

compiler/testData/diagnostics/tests/inference/nothingType/nullableExpectedTypeFromVariable.kt

@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !LANGUAGE: +NewInference
+// WITH_RUNTIME
+
+class Foo<T> {
+    private fun append(map: MutableMap<String, T>, field: String, appendedValue: T?) {
+        if (appendedValue != null) {
+            var currentValue: T? = map[field]
+            currentValue = if (currentValue == null) {
+                appendedValue
+            } else {
+                or(<!DEBUG_INFO_SMARTCAST!>currentValue<!>, <!DEBUG_INFO_SMARTCAST!>appendedValue<!>)
+            }
+            map[field] = <!DEBUG_INFO_SMARTCAST!>currentValue<!>
+        }
+    }
+
+    fun or(left: T, right: T): T = left
+}

compiler/testData/diagnostics/tests/inference/nothingType/nullableExpectedTypeFromVariable.txt

@@ -0,0 +1,10 @@
+package
+
+public final class Foo</*0*/ T> {
+    public constructor Foo</*0*/ T>()
+    private final fun append(/*0*/ map: kotlin.collections.MutableMap<kotlin.String, T>, /*1*/ field: kotlin.String, /*2*/ appendedValue: T?): kotlin.Unit
+    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 final fun or(/*0*/ left: T, /*1*/ right: T): T
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/inference/nothingType/reifiedParameterWithRecursiveBound.kt

@@ -27,8 +27,8 @@ inline fun <reified T : In<T>> testIn(): T {
 
 // Unexpected behaviour
 inline fun <reified T : Out<T>> testOut(): T {
-    <!UNREACHABLE_CODE!>return<!> try {
-        <!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>outBound<!>()
+    return try {
+        outBound()
     } catch (ex: Exception) {
         throw Exception()
     }

compiler/testData/diagnostics/tests/inference/nothingType/specialCallWithMaterializeAndExpectedType.fir.kt

@@ -0,0 +1,8 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo() {
+    val s: String? = if (true) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing?")!>materialize()<!> else null
+}
+
+fun <K> materialize(): K = TODO()

compiler/testData/diagnostics/tests/inference/nothingType/specialCallWithMaterializeAndExpectedType.kt

@@ -0,0 +1,8 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun foo() {
+    val s: String? = if (true) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String?")!>materialize()<!> else null
+}
+
+fun <K> materialize(): K = TODO()

compiler/testData/diagnostics/tests/inference/nothingType/specialCallWithMaterializeAndExpectedType.txt

@@ -0,0 +1,4 @@
+package
+
+public fun foo(): kotlin.Unit
+public fun </*0*/ K> materialize(): K

compiler/testData/diagnostics/tests/infos/SmartCasts.kt

@@ -142,10 +142,10 @@ fun getStringLength(obj : Any) : Char? {
 }
 
 fun toInt(i: Int?): Int = if (i != null) <!DEBUG_INFO_SMARTCAST!>i<!> else 0
-fun illegalWhenBody(a: Any): Int = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!>(a) {
+fun illegalWhenBody(a: Any): Int = <!NO_ELSE_IN_WHEN!>when<!>(a) {
     is Int -> <!DEBUG_INFO_SMARTCAST!>a<!>
-    is String -> <!OI;TYPE_MISMATCH!>a<!>
-}<!>
+    is String -> <!TYPE_MISMATCH!>a<!>
+}
 fun illegalWhenBlock(a: Any): Int {
     when(a) {
         is Int -> return <!DEBUG_INFO_SMARTCAST!>a<!>

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

@@ -34,6 +34,6 @@ fun main() {
         }
     }
 
-    val <!UNUSED_VARIABLE!>f<!> : String = <!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>a<!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>
+    val <!UNUSED_VARIABLE!>f<!> : String = <!TYPE_MISMATCH!>a<!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
     checkSubtype<String>(<!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>a<!><!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>)
 }

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

@@ -10,46 +10,46 @@ fun f1(s: Int?): Int {
 }
 
 fun f2(s: Int?): Int {
-    return <!NI;TYPE_MISMATCH!>when (s) {
-        !is Int -> <!OI;TYPE_MISMATCH!>s<!>
+    return when (s) {
+        !is Int -> <!TYPE_MISMATCH!>s<!>
         else -> <!DEBUG_INFO_SMARTCAST!>s<!>
-    }<!>
+    }
 }
 
 fun f3(s: Int?): Int {
-    return <!NI;TYPE_MISMATCH!>when (s) {
+    return when (s) {
         is Int -> <!DEBUG_INFO_SMARTCAST!>s<!>
-        else -> <!OI;TYPE_MISMATCH!>s<!>
-    }<!>
+        else -> <!TYPE_MISMATCH!>s<!>
+    }
 }
 
 fun f4(s: Int?): Int {
-    return <!NI;TYPE_MISMATCH!>when {
+    return when {
         s == 4 -> <!DEBUG_INFO_SMARTCAST!>s<!>
-        s == null -> <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>s<!>
+        s == null -> <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>s<!>
         else -> <!DEBUG_INFO_SMARTCAST!>s<!>
-    }<!>
+    }
 }
 
 fun f5(s: Int?): Int {
-    return <!NI;TYPE_MISMATCH!>when (s) {
-        s -> <!OI;TYPE_MISMATCH!>s<!>
+    return when (s) {
+        s -> <!TYPE_MISMATCH!>s<!>
         s!! -> <!DEBUG_INFO_SMARTCAST!>s<!>
         s -> <!DEBUG_INFO_SMARTCAST!>s<!>
         else -> 0
-    }<!>
+    }
 }
 
 fun f6(s: Int?): Int {
-    return <!NI;TYPE_MISMATCH!>when {
+    return when {
         s is Int -> <!DEBUG_INFO_SMARTCAST!>s<!>
-        else -> <!OI;TYPE_MISMATCH!>s<!>
-    }<!>
+        else -> <!TYPE_MISMATCH!>s<!>
+    }
 }
 
 fun f7(s: Int?): Int {
-    return <!NI;TYPE_MISMATCH!>when {
-        s !is Int -> <!OI;TYPE_MISMATCH!>s<!>
+    return when {
+        s !is Int -> <!TYPE_MISMATCH!>s<!>
         else -> <!DEBUG_INFO_SMARTCAST!>s<!>
-    }<!>
+    }
 }

compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt

@@ -17,16 +17,16 @@ fun test1(a: A.B.<!SYNTAX!><!>): A.B.<!SYNTAX!><!> {
 
 fun test2(a: A.<!UNRESOLVED_REFERENCE!>e<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!>): A.<!UNRESOLVED_REFERENCE!>e<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!> {
     val aa: A.<!UNRESOLVED_REFERENCE!>e<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!> = null!!
-}
+<!NI;NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 fun test3(a: <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>A<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!>): <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>A<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!> {
     val aa: <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>A<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>C<!> = null!!
-}
+<!NI;NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 fun test4(a: A.B.<!UNRESOLVED_REFERENCE!>ee<!>): A.B.<!UNRESOLVED_REFERENCE!>ee<!> {
     val aa: A.B.<!UNRESOLVED_REFERENCE!>ee<!> = null!!
-}
+<!NI;NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 fun test5(a: A.<!UNRESOLVED_REFERENCE!>ee<!>): A.<!UNRESOLVED_REFERENCE!>ee<!> {
     val aa: A.<!UNRESOLVED_REFERENCE!>ee<!> = null!!
-}
+<!NI;NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

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

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

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

@@ -2,6 +2,6 @@
 // !DIAGNOSTICS: -UNREACHABLE_CODE
 
 fun foo() {
-    val <!UNUSED_VARIABLE!>text<!>: List<Any> = null!!
+    val <!OI;UNUSED_VARIABLE!>text<!>: List<Any> = null!!
     text.<!UNRESOLVED_REFERENCE!>map<!> <!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Any<!><!SYNTAX!>?<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>toString<!>
 }

compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt

@@ -19,5 +19,5 @@ fun foo(): A.() -> Int {
     val b: Int = foo()(A())
     val c: Int = (foo())(A())
 
-    <!UNREACHABLE_CODE!>return<!> null!!
+    <!OI;UNREACHABLE_CODE!>return<!> null!!
 }

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

@@ -100,13 +100,13 @@ fun testTwoLambdas() {
         {}
         <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!>
 
-        return <!NI;TYPE_MISMATCH!>if (true) {
+        return if (true) <!NI;TYPE_MISMATCH!>{
             <!OI;TYPE_MISMATCH!>twoLambdaArgs({})
             {}
             <!MANY_LAMBDA_EXPRESSION_ARGUMENTS, UNEXPECTED_TRAILING_LAMBDA_ON_A_NEW_LINE!>{}<!><!>
-        } else <!NI;TYPE_MISMATCH!>{
+        }<!> else {
             {}
-        }<!><!>
+        }
     }
 }
 

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

@@ -4,7 +4,7 @@ fun foo(): String {
     s = null
     <!DEBUG_INFO_CONSTANT!>s<!>?.length
     <!OI;DEBUG_INFO_CONSTANT!>s<!><!UNSAFE_CALL!>.<!>length
-    if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> == null<!>) <!NI;UNREACHABLE_CODE!>return<!> <!ALWAYS_NULL!>s<!>!!
+    if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>s<!> == null<!>) return <!ALWAYS_NULL!>s<!>!!
     var t: String? = "y"
     if (t == null) t = "x"
     var x: Int? = null

compiler/testData/diagnostics/tests/smartCasts/publicVals/delegate.kt

@@ -14,7 +14,7 @@ class Example {
 
     public fun foo(): String {
         // Smart cast is not possible if property is delegated
-        return <!NI;TYPE_MISMATCH!>if (p != null) <!NI;SMARTCAST_IMPOSSIBLE, SMARTCAST_IMPOSSIBLE!>p<!> else ""<!>
+        return if (p != null) <!SMARTCAST_IMPOSSIBLE!>p<!> else ""
     }
 
     public fun bar(): String {

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

@@ -3,7 +3,7 @@
 
 fun basic(): String {
     var current: String? = null
-    current = if (current == null) "bar" else <!NI;DEBUG_INFO_SMARTCAST!>current<!>
+    current = if (current == null) "bar" else current
     return <!DEBUG_INFO_SMARTCAST!>current<!>
 }
 

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

@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 class MyClass
 
-operator fun MyClass.inc(): MyClass { <!UNREACHABLE_CODE!>return<!> null!! }
+operator fun MyClass.inc(): MyClass { <!OI;UNREACHABLE_CODE!>return<!> null!! }
 
 public fun box() : MyClass? {
     var i : MyClass?

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

@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 class MyClass
 
-operator fun MyClass.inc(): MyClass { <!UNREACHABLE_CODE!>return<!> null!! }
+operator fun MyClass.inc(): MyClass { <!OI;UNREACHABLE_CODE!>return<!> null!! }
 
 public fun box() {
     var i : MyClass?

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

@@ -19,16 +19,16 @@ class Foo<T> {
 fun test() {
     if (true) materialize() else null
 
-    val x1: String? = if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>() else null
+    val x1: String? = if (true) materialize() else null
 
-    val x2: String? = if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materializeWithGenericArg<!>("") else null
+    val x2: String? = if (true) materializeWithGenericArg("") else null
 
     val x3: String? = if (true) {
-        if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>() else null
+        if (true) materialize() else null
     } else null
 
     val x4: String? = if (true) {
-        select(<!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>(), null)
+        select(materialize(), null)
     } else null
 
     val x5: String? = select(if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>() else null, null)
@@ -61,7 +61,7 @@ fun test() {
 
     val x16: String? = when (boolean) {
         true -> null
-        false -> <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>()
+        false -> materialize()
         null -> null
     }
 
@@ -72,7 +72,7 @@ fun test() {
     }
 
     val x18: String? = try {
-        <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>()
+        materialize()
     } catch (e: Exception) {
         null
     }
@@ -81,11 +81,11 @@ fun test() {
 
     val x20: String? = if (true) materialize<String?>() else null
 
-    val x21: String? = if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>materialize<!>() else TODO()
+    val x21: String? = if (true) materialize() else TODO()
 
-    val x22: String? = if (true) return else <!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>materialize<!>()
+    val x22: String? = if (true) return else materialize()
 
-    val x23: String? = if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>id<!>(null) else null
+    val x23: String? = if (true) id(null) else null
 
     foo1(if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_AGAINST_NOT_NOTHING_EXPECTED_TYPE!>materialize<!>() else null)
 

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

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

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

@@ -11,12 +11,12 @@
  */
 
 fun test1(): Int {
-    val x: String = <!NI;TYPE_MISMATCH!>if (true) {
+    val x: String = if (true) <!NI;TYPE_MISMATCH!>{
         when {
             true -> <!OI;TYPE_MISMATCH!>Any()<!>
             else -> <!OI;NULL_FOR_NONNULL_TYPE!>null<!>
         }
-    } else ""<!>
+    }<!> else ""
     return x.hashCode()
 }