Introduce FirFunctionReturnTypeMismatchChecker

2021-04-03 22:58:19 +03:00
parent 24f1f1221e
commit 57d2eb5da2
80 changed files with 501 additions and 238 deletions
@@ -6,7 +6,7 @@ fun none() {}
 fun unitEmptyInfer() {}
 fun unitEmpty() : Unit {}
 fun unitEmptyReturn() : Unit {return}
-fun unitIntReturn() : Unit {return 1}
+fun unitIntReturn() : Unit {return <!RETURN_TYPE_MISMATCH!>1<!>}
 fun unitUnitReturn() : Unit {return Unit}
 fun test1() : Any = {<!RETURN_NOT_ALLOWED!>return<!>}
 fun test2() : Any = a@ {return@a 1}
@@ -16,7 +16,7 @@ fun test5(): Any = l@{ return@l }
 fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return<!> 1}

 fun bbb() {
-    return 1
+    return <!RETURN_TYPE_MISMATCH!>1<!>
 }

 fun foo(expr: StringBuilder): Int {
@@ -29,8 +29,8 @@ fun foo(expr: StringBuilder): Int {


 fun unitShort() : Unit = Unit
-fun unitShortConv() : Unit = 1
-fun unitShortNull() : Unit = null
+fun unitShortConv() : Unit = <!RETURN_TYPE_MISMATCH!>1<!>
+fun unitShortNull() : Unit = <!RETURN_TYPE_MISMATCH!>null<!>

 fun intEmpty() : Int {}
 fun intShortInfer() = 1
@@ -39,56 +39,56 @@ fun intShort() : Int = 1
 fun intBlock() : Int {return 1}
 fun intBlock1() : Int {1}

-fun intString(): Int = "s"
-fun intFunctionLiteral(): Int = { 10 }
+fun intString(): Int = <!RETURN_TYPE_MISMATCH!>"s"<!>
+fun intFunctionLiteral(): Int = <!RETURN_TYPE_MISMATCH!>{ 10 }<!>

-fun blockReturnUnitMismatch() : Int {return}
-fun blockReturnValueTypeMismatch() : Int {return 3.4}
+fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
+fun blockReturnValueTypeMismatch() : Int {return <!RETURN_TYPE_MISMATCH!>3.4<!>}
 fun blockReturnValueTypeMatch() : Int {return 1}
-fun blockReturnValueTypeMismatchUnit() : Int {return Unit}
+fun blockReturnValueTypeMismatchUnit() : Int {return <!RETURN_TYPE_MISMATCH!>Unit<!>}

 fun blockAndAndMismatch() : Int {
    true && false
    }
 fun blockAndAndMismatch1() : Int {
-    return true && false
+    return <!RETURN_TYPE_MISMATCH!>true && false<!>
 }
 fun blockAndAndMismatch2() : Int {
-    (return true) && (return false)
+    (return <!RETURN_TYPE_MISMATCH!>true<!>) && (return <!RETURN_TYPE_MISMATCH!>false<!>)
 }

 fun blockAndAndMismatch3() : Int {
    true || false
    }
 fun blockAndAndMismatch4() : Int {
-    return true || false
+    return <!RETURN_TYPE_MISMATCH!>true || false<!>
 }
 fun blockAndAndMismatch5() : Int {
-    (return true) || (return false)
+    (return <!RETURN_TYPE_MISMATCH!>true<!>) || (return <!RETURN_TYPE_MISMATCH!>false<!>)
 }
 fun blockReturnValueTypeMatch1() : Int {
-    return if (1 > 2) 1.0 else 2.0
+    return <!RETURN_TYPE_MISMATCH!>if (1 > 2) 1.0 else 2.0<!>
 }
 fun blockReturnValueTypeMatch2() : Int {
    return <!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2) 1
 }
 fun blockReturnValueTypeMatch3() : Int {
-    return if (1 > 2) else 1
+    return <!RETURN_TYPE_MISMATCH!>if (1 > 2) else 1<!>
 }
 fun blockReturnValueTypeMatch4() : Int {
    if (1 > 2)
-        return 1.0
-    else return 2.0
+        return <!RETURN_TYPE_MISMATCH!>1.0<!>
+    else return <!RETURN_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch5() : Int {
    if (1 > 2)
-        return 1.0
-    return 2.0
+        return <!RETURN_TYPE_MISMATCH!>1.0<!>
+    return <!RETURN_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch6() : Int {
    if (1 > 2)
-    else return 1.0
-    return 2.0
+    else return <!RETURN_TYPE_MISMATCH!>1.0<!>
+    return <!RETURN_TYPE_MISMATCH!>2.0<!>
 }
 fun blockReturnValueTypeMatch7() : Int {
    if (1 > 2)
@@ -116,7 +116,7 @@ fun blockReturnValueTypeMatch11() : Int {
 fun blockReturnValueTypeMatch12() : Int {
    if (1 > 2)
        return 1
-    else return 1.0
+    else return <!RETURN_TYPE_MISMATCH!>1.0<!>
 }
 fun blockNoReturnIfValDeclaration(): Int {
    val x = 1
@@ -134,23 +134,23 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
        }
    }
    }
-fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) {} else {}
-fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) {} else 2
+fun nonBlockReturnIfEmptyIf(): Int = <!RETURN_TYPE_MISMATCH!>if (1 < 2) {} else {}<!>
+fun nonBlockNoReturnIfUnitInOneBranch(): Int = <!RETURN_TYPE_MISMATCH!>if (1 < 2) {} else 2<!>

 val a = <!RETURN_NOT_ALLOWED!>return<!> 1

 class A() {
 }
-fun illegalConstantBody(): Int = "s"
+fun illegalConstantBody(): Int = <!RETURN_TYPE_MISMATCH!>"s"<!>
 fun illegalConstantBlock(): String {
-    return 1
+    return <!RETURN_TYPE_MISMATCH!>1<!>
 }
 fun illegalIfBody(): Int =
-        if (1 < 2) 'a' else { 1.0 }
+        <!RETURN_TYPE_MISMATCH!>if (1 < 2) 'a' else { 1.0 }<!>
 fun illegalIfBlock(): Boolean {
    if (1 < 2)
        return false
-    else { return 1 }
+    else { return <!RETURN_TYPE_MISMATCH!>1<!> }
 }
 fun illegalReturnIf(): Char {
    return if (1 < 2) 'a' else { 1 }
@@ -19,6 +19,6 @@ class A3<T> {
    fun test2(): (T) -> Unit = A3<T>()::a3
    fun test3(): (Int) -> String = A3<Int>()::a3

-    fun <R> test4(): (R) -> Unit = this::a3
+    fun <R> test4(): (R) -> Unit = <!RETURN_TYPE_MISMATCH!>this::a3<!>
    fun <R> test5(): (T) -> R = this::a3
 }
@@ -20,6 +20,6 @@ public interface Executor {
 fun f(): String = "test"

 class A {
-    fun schedule1(e: Executor): Future<String> = e.submit(::f)
-    fun schedule2(e: Executor): Future<String> = e.submit { f() }
+    fun schedule1(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH!>e.submit(::f)<!>
+    fun schedule2(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH!>e.submit { f() }<!>
 }
@@ -20,12 +20,12 @@ operator fun Impl2.unaryMinus() = Impl2()
 // See also KT-10384: in non-error functions, as is necessary!
 fun add1(x: Impl2, y: Base): Impl1 = x as Base + y

-fun error1(x: Impl2, y: Base): Impl1 = x + y
+fun error1(x: Impl2, y: Base): Impl1 = <!RETURN_TYPE_MISMATCH!>x + y<!>

 fun add2(x: Base, y: Impl2): Impl1 = x + y as Base

-fun error2(x: Base, y: Impl2): Impl1 = x + y
+fun error2(x: Base, y: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH!>x + y<!>

 fun minus3(x: Impl2): Impl1 = -(x as Base)

-fun error3(x: Impl2): Impl1 = -x
+fun error3(x: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH!>-x<!>
@@ -4,7 +4,7 @@ fun <T> f1(): KClass<Array<T>> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>Array<T>::clas
 fun <T> f2(): KClass<Array<Array<T>>> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>Array<Array<T>>::class<!>
 inline fun <reified T> f3() = Array<T>::class
 inline fun <reified T> f4() = Array<Array<T>>::class
-fun f5(): KClass<Array<Any>> = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>Array<*>::class<!>
+fun f5(): KClass<Array<Any>> = <!CLASS_LITERAL_LHS_NOT_A_CLASS, RETURN_TYPE_MISMATCH!>Array<*>::class<!>
 fun f6(): KClass<Array<Int?>> = Array<Int?>::class
 fun f7() = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>Array<List<String>>::class<!>
 fun f8() = <!CLASS_LITERAL_LHS_NOT_A_CLASS!>Array<List<String>?>::class<!>
@@ -0,0 +1,23 @@
+// KT-16291 Smart cast doesn't work when getting class of instance
+
+import kotlin.reflect.KClass
+
+class Foo {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other === null || other::class != this::class) return false
+
+        return true
+    }
+}
+
+fun test(f: Foo?): KClass<out Foo>? = if (f != null) f::class else null
+
+fun test2(): KClass<out Foo>? {
+    var f: Foo? = null
+    if (f != null) {
+        run { f = null }
+        return <!RETURN_TYPE_MISMATCH!><!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>f<!>::class<!>
+    }
+    return null
+}
@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // KT-16291 Smart cast doesn't work when getting class of instance

 import kotlin.reflect.KClass
@@ -6,7 +6,7 @@ fun t1() : Int{
 }

 fun t1a() : Int {
-  return
+  <!RETURN_TYPE_MISMATCH!>return<!>
  return 1
  1
 }
@@ -19,7 +19,7 @@ fun t1b() : Int {

 fun t1c() : Int {
  return 1
-  return
+  <!RETURN_TYPE_MISMATCH!>return<!>
  1
 }

@@ -35,5 +35,5 @@ val bbbb = ( l() ?: null) ?: ( l() ?: null)

 fun f(x : Long?): Long {
    var a = x ?: (fun() {} ?: fun() {})
-    return a
+    return <!RETURN_TYPE_MISMATCH!>a<!>
 }
@@ -33,15 +33,15 @@ fun testReturnFromAnonFun() =

 fun testReturn1() =
        run {
-            return if (true) 42
-                   else println()
+            return <!RETURN_TYPE_MISMATCH!>if (true) 42
+                   else println()<!>
        }

 fun testReturn2() =
        run {
-            return if (true) 42
+            return <!RETURN_TYPE_MISMATCH!>if (true) 42
                   else if (true) 42
-                   else println()
+                   else println()<!>
        }

 fun testUsage1() =
@@ -1,21 +1,21 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNREACHABLE_CODE -UNUSED_PARAMETER -RETURN_NOT_ALLOWED

 fun test1() = run {
-    return "OK"
+    return <!RETURN_TYPE_MISMATCH!>"OK"<!>
 }

 fun test2() = run {
    fun local(): String {
        return ""
    }
-    return ""
+    return <!RETURN_TYPE_MISMATCH!>""<!>
 }

 inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> = null!!
 fun test3(a: List<String>, b: List<Int>) = a.map {
-    if (it.length == 3) return null
-    if (it.length == 4) return ""
-    if (it.length == 4) return 5
+    if (it.length == 3) return <!RETURN_TYPE_MISMATCH!>null<!>
+    if (it.length == 4) return <!RETURN_TYPE_MISMATCH!>""<!>
+    if (it.length == 4) return <!RETURN_TYPE_MISMATCH!>5<!>
    if (it.length == 4) return b
    1
 }
@@ -24,14 +24,14 @@ fun test4() = run {
    fun test5() {
        return

-        return@test4
+        <!RETURN_TYPE_MISMATCH!>return@test4<!>

-        return return@test4
+        return <!RETURN_TYPE_MISMATCH!>return@test4<!>

-        return fun() { return; return@test4 "" }
+        return <!RETURN_TYPE_MISMATCH!>fun() { return; return@test4 <!RETURN_TYPE_MISMATCH!>""<!> }<!>
    }

-    return
+    <!RETURN_TYPE_MISMATCH!>return<!>
    3
 }

@@ -43,5 +43,5 @@ val foo: Int
    }

 fun test(): Int = run {
-    return ""
+    return <!RETURN_TYPE_MISMATCH!>""<!>
 }
@@ -2,11 +2,11 @@
 package f

 fun test(a: Boolean, b: Boolean): Int {
-    return if(a) {
+    return <!RETURN_TYPE_MISMATCH!>if(a) {
        1
    } else {
        if (b) {
            3
        }
-    }
+    }<!>
 }
@@ -10,7 +10,7 @@ fun f() = object : ClassData {
 fun g() = object : ClassData {
    init {
        if (true) {
-            <!RETURN_NOT_ALLOWED!>return<!> 0
+            <!RETURN_NOT_ALLOWED!>return<!> <!RETURN_TYPE_MISMATCH!>0<!>
        }
    }

@@ -17,4 +17,4 @@ fun g() = object : ClassData {
    fun some(): Int {
        return 6
    }
-}
+}
@@ -6,15 +6,15 @@ fun foo() : Int {
        doSmth()
    }
    catch (e: Exception) {
-        return ""
+        return <!RETURN_TYPE_MISMATCH!>""<!>
    }
    finally {
-        return ""
+        return <!RETURN_TYPE_MISMATCH!>""<!>
    }
 }

 fun bar() : Int =
-    try {
+    <!RETURN_TYPE_MISMATCH!>try {
        doSmth()
    }
    catch (e: Exception) {
@@ -22,7 +22,7 @@ fun bar() : Int =
    }
    finally {
        ""
-    }
+    }<!>


 fun doSmth() {}
@@ -26,22 +26,22 @@ fun testResultOfLambda2() =

 fun testReturn1() =
        run {
-            return when {
+            return <!RETURN_TYPE_MISMATCH!>when {
                true -> 42
                else -> println()
-            }
+            }<!>
        }

 fun testReturn2() =
        run {
-            return when {
+            return <!RETURN_TYPE_MISMATCH!>when {
                true -> 42
                else ->
                    when {
                        true -> 42
                        else -> println()
                    }
-            }
+            }<!>
        }

 fun testUsage1() =
@@ -14,5 +14,5 @@ fun foo(): Int {
    val z: Int? = null
    if (z != null) return if (z == null) z else z

-    return z
+    return <!RETURN_TYPE_MISMATCH!>z<!>
 }
@@ -1,36 +1,36 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 // KT-5068 Add special error for scala-like syntax 'fun foo(): Int = { 1 }'

-fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
-fun test2(): Int = { 1 }
+fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
 val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
 val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
-fun test5(): Int { return { 1 } }
-fun test6(): Int = fun (): Int = 1
+fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
+fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>

 fun outer() {
-    fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
-    fun test2(): Int = { 1 }
+    fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+    fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
    val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
    val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
-    fun test5(): Int { return { 1 } }
-    fun test6(): Int = fun (): Int = 1
+    fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
+    fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>
 }

 class Outer {
-    fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
-    fun test2(): Int = { 1 }
+    fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+    fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
    val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
    val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
-    fun test5(): Int { return { 1 } }
-    fun test6(): Int = fun (): Int = 1
+    fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
+    fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>

    class Nested {
-        fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
-        fun test2(): Int = { 1 }
+        fun test1(): Int = <!RETURN_TYPE_MISMATCH!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
+        fun test2(): Int = <!RETURN_TYPE_MISMATCH!>{ 1 }<!>
        val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
        val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
-        fun test5(): Int { return { 1 } }
-        fun test6(): Int = fun (): Int = 1
+        fun test5(): Int { return <!RETURN_TYPE_MISMATCH!>{ 1 }<!> }
+        fun test6(): Int = <!RETURN_TYPE_MISMATCH!>fun (): Int = 1<!>
    }
 }
@@ -9,12 +9,12 @@ fun <T> foo(): T {
    bar<T>(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
    bar<T?>(null)

-    return null
+    return <!RETURN_TYPE_MISMATCH!>null<!>
 }

 fun <T> baz(): T? = null

-fun <T> foobar(): T = null
+fun <T> foobar(): T = <!RETURN_TYPE_MISMATCH!>null<!>

 class A<F> {
    fun xyz(x: F) {}
@@ -26,10 +26,10 @@ class A<F> {
        xyz(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
        bar<F?>(null)

-        return null
+        return <!RETURN_TYPE_MISMATCH!>null<!>
    }

    fun baz(): F? = null

-    fun foobar(): F = null
+    fun foobar(): F = <!RETURN_TYPE_MISMATCH!>null<!>
 }
@@ -0,0 +1,11 @@
+class Foo<out T>(val baz: Baz<T>)
+
+class Bar {
+    val foo: Foo<*> = TODO()
+
+    fun <T> bar(): Baz<T> {
+        return <!RETURN_TYPE_MISMATCH!>foo.baz<!>
+    }
+}
+
+typealias Baz<T> = (@UnsafeVariance T) -> Unit
@@ -1,5 +1,3 @@
-// FIR_IDENTICAL
-
 class Foo<out T>(val baz: Baz<T>)

 class Bar {
@@ -10,4 +8,4 @@ class Bar {
    }
 }

-typealias Baz<T> = (@UnsafeVariance T) -> Unit
+typealias Baz<T> = (@UnsafeVariance T) -> Unit
@@ -17,7 +17,7 @@ fun check() {
    val x = null!!
 }

-fun nonLocalReturn() = run { return }
+fun nonLocalReturn() = run { <!RETURN_TYPE_MISMATCH!>return<!> }

 class Klass {
    fun bar() = null!!
@@ -12,7 +12,7 @@ fun foo(): String? {
    run {
        if (true) return@run

-        if (true) return Obj() // correct error, type check against return type of function "foo"
+        if (true) return <!RETURN_TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
    }

    run {
@@ -23,4 +23,4 @@ fun noCoercionBlockHasExplicitReturn() {
    }
 }

-fun noCoercionInExpressionBody(): Unit = "hello"
+fun noCoercionInExpressionBody(): Unit = <!RETURN_TYPE_MISMATCH!>"hello"<!>
@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // Related issue: KT-28654

-fun <K> select(): K = run { }
+fun <K> select(): K = <!RETURN_TYPE_MISMATCH!>run { }<!>

 fun test() {
    val x: Int = select()
@@ -149,7 +149,7 @@ fun illegalWhenBody(a: Any): Int = <!NO_ELSE_IN_WHEN!>when<!>(a) {
 fun illegalWhenBlock(a: Any): Int {
    when(a) {
        is Int -> return a
-        is String -> return a
+        is String -> return <!RETURN_TYPE_MISMATCH!>a<!>
    }
 }
 fun declarations(a: Any?) {
@@ -222,7 +222,7 @@ fun f(): String {
 fun foo(aa: Any?): Int {
    var a = aa
    if (a is Int?) {
-        return a
+        return <!RETURN_TYPE_MISMATCH!>a<!>
    }
    return 1
 }
@@ -30,5 +30,5 @@ import p2.*

 fun test2(): Int {
    val r = foo(42)
-    return r
+    return <!RETURN_TYPE_MISMATCH!>r<!>
 }
@@ -2,8 +2,8 @@ interface A

 interface B

-fun test1(): B = object : A {
-}
+fun test1(): B = <!RETURN_TYPE_MISMATCH!>object : A {
+}<!>

-fun test2(): B = object {
-}
+fun test2(): B = <!RETURN_TYPE_MISMATCH!>object {
+}<!>
@@ -3,7 +3,7 @@ interface A {
 }

 interface B : A {
-    override fun test(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Unit<!> = "B"
+    override fun test(): <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Unit<!> = <!RETURN_TYPE_MISMATCH!>"B"<!>
 }

 open class C : A
@@ -9,7 +9,7 @@ fun <T> f(expression : T) : G<out T> = G<T>()

 fun foo() : G<Point> {
  val p = Point()
-  return f<Point>(p)
+  return <!RETURN_TYPE_MISMATCH!>f<Point>(p)<!>
 }

 class Out<out T>() {}
@@ -35,7 +35,7 @@ fun t3() : String {
            <!RETURN_NOT_ALLOWED!>return@t3<!> "1"
        }
        else {
-            <!RETURN_NOT_ALLOWED!>return<!> 2
+            <!RETURN_NOT_ALLOWED!>return<!> <!RETURN_TYPE_MISMATCH!>2<!>
        }
        return@l 0
    }
@@ -111,8 +111,8 @@ fun testTwoLambdas() {
 }

 fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
-    return { l1 ->
+    return <!RETURN_TYPE_MISMATCH!>{ l1 ->
        l1()
        <!TOO_MANY_ARGUMENTS!>{ l2 -> <!UNRESOLVED_REFERENCE!>l2<!>() }<!>
-    }
+    }<!>
 }
@@ -16,7 +16,7 @@ fun <T> LiveData<T>.observe(a: Any, observer: (T) -> Unit): Observer<T> {
 }

 // FILE: test.kt
-fun <T> test1(r: Runnable, l: LiveData<T>): Observer<T> = l.observe(r) {  } // partial conversion
+fun <T> test1(r: Runnable, l: LiveData<T>): Observer<T> = <!RETURN_TYPE_MISMATCH!>l.observe(r) {  }<!> // partial conversion

 fun <T> test2(r: Runnable, o: Observer<T>, l: LiveData<T>) {
    val a = l.observe(r, o) // no conversion
@@ -33,5 +33,5 @@ fun baz(s: String?, r: String?): String {
 fun withNull(s: String?): String {
    val t = s ?: null
    // Error: nullable
-    return t
+    return <!RETURN_TYPE_MISMATCH!>t<!>
 }
@@ -8,7 +8,7 @@ class Immutable(val x: String?) {

 class Mutable(var y: String?) {
    fun foo(): String {
-        if (y != null) return y
+        if (y != null) return <!RETURN_TYPE_MISMATCH!>y<!>
        return ""
    }
 }
@@ -3,5 +3,5 @@
 fun calc(x: List<String>?, y: Int?): Int {
    x?.subList(y!! - 1, y)
    // y!! above should not provide smart cast here
-    return y
+    return <!RETURN_TYPE_MISMATCH!>y<!>
 }
@@ -6,5 +6,5 @@ fun calc(x: String?, y: Int?): Int {
    // Smart cast because of x!! in receiver
    foo(x!!)?.subSequence(y!!, x.length)?.length
    // No smart cast possible
-    return y
+    return <!RETURN_TYPE_MISMATCH!>y<!>
 }
@@ -13,5 +13,5 @@ fun list(start: SomeObject): SomeObject {
        e = e<!UNSAFE_CALL!>.<!>next()
    }
    // Smart cast is not possible here due to next()
-    return e
+    return <!RETURN_TYPE_MISMATCH!>e<!>
 }
@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
        e.doSomething()
        e = e.next()
    }
-    return e
+    return <!RETURN_TYPE_MISMATCH!>e<!>
 }
@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
        e.doSomething()
        e = e.next()
    }
-    return e
+    return <!RETURN_TYPE_MISMATCH!>e<!>
 }
@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>): Int {
    val inner = javaClass.createInner<String>()
-    return inner.doSomething(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "") { }
+    return <!RETURN_TYPE_MISMATCH!>inner.doSomething(<!ARGUMENT_TYPE_MISMATCH!>1<!>, "") { }<!>
 }

 // FILE: JavaClass.java
@@ -40,7 +40,7 @@ class Context<T>
 fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()

 fun <T> Any?.decodeOut1(typeFrom: Context<out T>): T {
-    return this?.decodeIn(typeFrom) ?: kotlin.Unit
+    return <!RETURN_TYPE_MISMATCH!>this?.decodeIn(typeFrom) ?: kotlin.Unit<!>
 }

 fun <T> Any.decodeOut2(typeFrom: Context<out T>): T {
@@ -4,4 +4,4 @@ fun ushort(vararg a: UShort): UShortArray = a
 fun uint(vararg a: UInt): UIntArray = a
 fun ulong(vararg a: ULong): ULongArray = a

-fun rawUInt(vararg a: UInt): IntArray = a
+fun rawUInt(vararg a: UInt): IntArray = <!RETURN_TYPE_MISMATCH!>a<!>
@@ -18,5 +18,5 @@ fun test(a: Any): String {
        is A -> q!!
    }
    // When is not exhaustive
-    return q
+    return <!RETURN_TYPE_MISMATCH!>q<!>
 }
@@ -18,5 +18,5 @@ fun test(a: Any) {
        is A -> q = "1"
    }
    // When is not exhaustive
-    return q
+    return <!RETURN_TYPE_MISMATCH!>q<!>
 }
@@ -14,14 +14,14 @@ package test

 fun foo(): Int {
    val a = "a"
-    return if (a.length > 0) {
+    return <!RETURN_TYPE_MISMATCH!>if (a.length > 0) {
        when (a) {
            "a" -> 1
        }
    }
    else {
        3
-    }
+    }<!>
 }

 fun bar(): Int {
@@ -15,5 +15,5 @@ public class P {

 fun foo(c: P): MutableList<Int> {
    // Error should be here: see KT-8168 Typechecker fails for platform collection type
-    return c.getList() ?: listOf()
+    return <!RETURN_TYPE_MISMATCH!>c.getList() ?: listOf()<!>
 }
@@ -5,9 +5,9 @@ import kotlin.comparisons.nullsLast
 class Foo(val a: String, val b: Int)

 fun getComp(): Comparator<Foo?> =
-        when {
+        <!RETURN_TYPE_MISMATCH!>when {
            else -> nullsLast(compareBy({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> }))
-        }
+        }<!>

 fun getCompInverted(): Comparator<Foo?> =
        nullsLast(