[FIR] Add NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY diagnostic

2021-07-08 15:29:31 +03:00
parent 151478aa27
commit a6984c5198
97 changed files with 939 additions and 1151 deletions
@@ -31,12 +31,12 @@ fun unitShort() : Unit = Unit
 fun unitShortConv() : Unit = <!RETURN_TYPE_MISMATCH!>1<!>
 fun unitShortNull() : Unit = <!NULL_FOR_NONNULL_TYPE!>null<!>

-fun intEmpty() : Int {}
+fun intEmpty() : Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun intShortInfer() = 1
 fun intShort() : Int = 1
 //fun intBlockInfer()  {1}
 fun intBlock() : Int {return 1}
-fun intBlock1() : Int {1}
+fun intBlock1() : Int {1<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun intString(): Int = <!RETURN_TYPE_MISMATCH!>"s"<!>
 fun intFunctionLiteral(): Int = <!RETURN_TYPE_MISMATCH!>{ 10 }<!>
@@ -48,7 +48,7 @@ fun blockReturnValueTypeMismatchUnit() : Int {return <!RETURN_TYPE_MISMATCH!>Uni

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

 fun blockAndAndMismatch3() : Int {
    true || false
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockAndAndMismatch4() : Int {
    return <!RETURN_TYPE_MISMATCH!>true || false<!>
 }
@@ -93,7 +93,7 @@ fun blockReturnValueTypeMatch7() : Int {
    if (1 > 2)
    1.0
    else 2.0
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch8() : Int {
    if (1 > 2)
    1.0
@@ -103,7 +103,7 @@ fun blockReturnValueTypeMatch8() : Int {
 fun blockReturnValueTypeMatch9() : Int {
    if (1 > 2)
    1.0
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch10() : Int {
    return <!INVALID_IF_AS_EXPRESSION!>if<!> (1 > 2)
    1
@@ -111,7 +111,7 @@ fun blockReturnValueTypeMatch10() : Int {
 fun blockReturnValueTypeMatch11() : Int {
    if (1 > 2)
    else 1.0
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockReturnValueTypeMatch12() : Int {
    if (1 > 2)
        return 1
@@ -119,10 +119,10 @@ fun blockReturnValueTypeMatch12() : Int {
 }
 fun blockNoReturnIfValDeclaration(): Int {
    val x = 1
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockNoReturnIfEmptyIf(): Int {
    if (1 < 2) {} else {}
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun blockNoReturnIfUnitInOneBranch(): Int {
    if (1 < 2) {
        return 1
@@ -132,7 +132,7 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
            return 2
        }
    }
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun nonBlockReturnIfEmptyIf(): Int = <!RETURN_TYPE_MISMATCH!>if (1 < 2) {} else {}<!>
 fun nonBlockNoReturnIfUnitInOneBranch(): Int = <!RETURN_TYPE_MISMATCH!>if (1 < 2) {} else 2<!>

@@ -98,33 +98,33 @@ interface Example3 {



-operator fun Example.plus(o: Any): Example {}
-operator fun Example.div(o: Example): Example {}
-operator fun Example.plus(o: Example, s: String = ""): Example {}
-operator fun Example.minus(vararg o: Example): Example {}
-operator fun Example.plus(): Example {}
-operator fun Example.minus(): Example {}
+operator fun Example.plus(o: Any): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.div(o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.plus(o: Example, s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.minus(vararg o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.plus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.minus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.unaryPlus(): Example {}
-operator fun Example.unaryMinus(): Example {}
+operator fun Example.unaryPlus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.unaryMinus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.unaryPlus(s: String = ""): Example {}
+operator fun Example.unaryPlus(s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 operator fun Example.unaryMinus(o: Example) {}

-operator fun Example.inc(): Example {}
-operator fun Example.dec(): Example? {}
+operator fun Example.inc(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.dec(): Example? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 operator fun Example.plusAssign(n: Int) {}
-operator fun Example.minusAssign(n: Int): String {}
+operator fun Example.minusAssign(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 operator fun Example.divAssign(n: Int, a: String = "") {}
 operator fun Example.modAssign(vararg n: Int) {}

-operator fun Example.compareTo(other: Example): Int {}
+operator fun Example.compareTo(other: Example): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.equals(a: String): Boolean {}
+operator fun Example.equals(a: String): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.contains(n: Int): Boolean {}
-operator fun Example.contains(n: Int, s: String = ""): Boolean {}
+operator fun Example.contains(n: Int): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.contains(n: Int, s: String = ""): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 operator fun Example.invoke() {}

@@ -140,18 +140,18 @@ operator fun Example.rangeTo(o: Int) {}
 operator fun Example.rangeTo(o: Int, o2: Int) {}
 operator fun Example.rangeTo(vararg o: String) {}

-operator fun Example.component1(): Int {}
-operator fun Example.component1(n: Int): Int {}
-operator fun Example.componentN(): Int {}
+operator fun Example.component1(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.component1(n: Int): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.componentN(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.iterator(): String {}
-operator fun Example.iterator(n: Int): String {}
+operator fun Example.iterator(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.iterator(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.next(): String {}
-operator fun Example.next(n: Int): String {}
+operator fun Example.next(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.next(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun Example.hasNext(): Boolean {}
-operator fun Example.hasNext(n: Int): String {}
+operator fun Example.hasNext(): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun Example.hasNext(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 infix fun Example.i1(n: Int) {}
 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun Example.i1(n: Int, n2: Int) {}<!>
@@ -161,31 +161,31 @@ infix fun Example.i1(vararg n: Int) {}



-operator fun plus(o: String): Example {}
-operator fun div(o: Example): Example {}
-operator fun plus(o: Example, s: String = ""): Example {}
-operator fun minus(vararg o: Example): Example {}
+operator fun plus(o: String): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun div(o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun plus(o: Example, s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun minus(vararg o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun unaryPlus(): Example {}
-operator fun unaryMinus(): Example {}
+operator fun unaryPlus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun unaryMinus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun unaryPlus(s: String = ""): Example {}
+operator fun unaryPlus(s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 operator fun unaryMinus(o: Example) {}

-operator fun inc(): Example {}
-operator fun dec(): Example? {}
+operator fun inc(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun dec(): Example? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 operator fun plusAssign(n: Int) {}
-operator fun minusAssign(n: Int): String {}
+operator fun minusAssign(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 operator fun divAssign(n: Int, a: String = "") {}
 operator fun modAssign(vararg n: Int) {}

-operator fun compareTo(other: Example): Int {}
+operator fun compareTo(other: Example): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun equals(a: String): Boolean {}
+operator fun equals(a: String): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun contains(n: Int): Boolean {}
-operator fun contains(n: Int, s: String = ""): Boolean {}
+operator fun contains(n: Int): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun contains(n: Int, s: String = ""): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 operator fun invoke() {}

@@ -201,18 +201,18 @@ operator fun rangeTo(o: Int) {}
 operator fun rangeTo(o: Int, o2: Int) {}
 operator fun rangeTo(vararg o: String) {}

-operator fun component1(): Int {}
-operator fun component1(n: Int): Int {}
-operator fun componentN(): Int {}
+operator fun component1(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun component1(n: Int): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun componentN(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun iterator(): String {}
-operator fun iterator(n: Int): String {}
+operator fun iterator(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun iterator(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun next(): String {}
-operator fun next(n: Int): String {}
+operator fun next(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun next(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-operator fun hasNext(): Boolean {}
-operator fun hasNext(n: Int): String {}
+operator fun hasNext(): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun hasNext(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun i1(n: Int) {}<!>
 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun i1(n: Int, n2: Int) {}<!>
@@ -1,18 +0,0 @@
-class C<T>() {
-  fun foo() : T {}
-}
-
-fun foo(c: C<Int>) {}
-fun <T> bar() : C<T> {}
-
-fun main() {
-  val a : C<Int> = C();
-  val x : C<in String> = C()
-  val y : C<out String> = C()
-  val z : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
-
-  val ba : C<Int> = bar();
-  val bx : C<in String> = bar()
-  val by : C<out String> = bar()
-  val bz : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class C<T>() {
  fun foo() : T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 }
@@ -1,13 +0,0 @@
-interface X {
-    fun f(): Boolean
-}
-
-val m = object : X {
-    override fun f(): Boolean {
-    }
-
-    fun foo() {
-        fun local(): Int {
-        }
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 interface X {
    fun f(): Boolean
 }
@@ -1,17 +0,0 @@
-package f
-
-
-//KT-3444 Front-end doesn't check if local function or function of anonymous class returns value
-
-fun box(): Int {
-
-    fun local(): Int {
-    }
-
-    return local()
-}
-
-fun main() {
-    box()
-}
-
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package f


@@ -7,10 +7,10 @@ class A {}
 package test.p; class C {fun f() {}}

 // FILE: c.kt
-package test.p; open class G<T> {open fun f(): T {} fun a() {}}
+package test.p; open class G<T> {open fun f(): T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!> fun a() {}}

 // FILE: d.kt
-package test.p; class G2<E> : <!SUPERTYPE_NOT_INITIALIZED!>G<E><!> { fun g() : E {} override fun f() : E {}}
+package test.p; class G2<E> : <!SUPERTYPE_NOT_INITIALIZED!>G<E><!> { fun g() : E {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!> override fun f() : E {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>}

 // FILE: e.kt
 package test.p; fun foo() {}
@@ -3,4 +3,4 @@ fun illegalWhenBlock(a: Any): Int {
        is Int -> return a
        is String -> return a.length
    }
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -1,13 +0,0 @@
-fun box() {
-    fun local():Int {
-    }
-}
-
-interface X {
-    fun f(): Boolean
-}
-
-val m = object : X {
-    override fun f(): Boolean {
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun box() {
    fun local():Int {
    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -10,19 +10,19 @@ val closure = {
    }

    fun h(): Int { // error: should be NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY
-    }
+    <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 }

 class A {
    init {
        fun foo(): Int {
-        }
+        <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

        val closure = {
            val x = ""

            fun local(): Int {
-            }
+            <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
        }

        val y = ""
@@ -7,7 +7,7 @@ fun f() {

            fun loc1(): Int {
                val x1_ = "" // ok: unused
-            }
+            <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
        }

        fun f() {
@@ -15,12 +15,12 @@ fun f() {

            fun loc2(): Int {
                val x2_ = "" // error: should be UNUSED_VARIABLE
-            }
+            <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
        }

        val v: String
            get() {
                val x3 = "" // ok: unused
-            }
+            <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
    }
 }
@@ -9,7 +9,7 @@ fun foo() : Int {
        <!ELSE_MISPLACED_IN_WHEN!>else<!> -> { z = -1000 }
        return z -> 34
    }
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 //test unreachable code
 fun fff(): Int {
@@ -18,13 +18,13 @@ fun main() {
    val a6: () -> Int = (fun() = 1)
    val a7: () -> Int = (fun(): String = "1") as () -> Int
    val a8: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): String = "1"<!>
-    val a9: () -> () -> () -> Int = fun(): () -> () -> String = fun(): () -> String = fun(): String = "1"
+    val a9: () -> () -> () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): () -> () -> String = fun(): () -> String = fun(): String = "1"<!>

    foo(<!ARGUMENT_TYPE_MISMATCH!>fun(): String = "1"<!>)
    foo(((<!ARGUMENT_TYPE_MISMATCH!>fun(): String = "1"<!>)))

    val a10: Int.(String) -> Int = fun (x: String) = 10
-    val a11: () -> () -> () -> Int = fun() = fun() = fun(): String = "1"
+    val a11: () -> () -> () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun() = fun(): String = "1"<!>

    val a12: Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): String = "1"<!>
    val a13: Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun(): String = "1"<!>
@@ -34,7 +34,7 @@ fun main() {

    val a17: () -> Unit = fun() {}
    val a18: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun() {}<!>
-    val a19: () -> () -> Int = fun() = fun() {}
+    val a19: () -> () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun() {}<!>
    val a20: () -> () -> () -> Unit = fun() = fun() = {}
    val a21: () -> () -> () -> Int = fun() = fun() = {}
 }
@@ -33,4 +33,4 @@ fun <T: Foo<<!UNRESOLVED_REFERENCE!>String.Bar<!>>> x() {}
 fun Foo<String>.Bar.ext() {}

 fun ex1(a: Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar<String>): Foo<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><String><!>.Bar<String> {
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -21,4 +21,4 @@ fun bar(i: Int, a: <!UNRESOLVED_REFERENCE!>U<!>) {
 }

 //from standard library
-public inline fun <T> comparator(fn: (T,T) -> Int): Comparator<T> {}
+public inline fun <T> comparator(fn: (T,T) -> Int): Comparator<T> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -3,7 +3,7 @@ package d

 interface A<T>

-fun <T> infer(a: A<T>) : T {}
+fun <T> infer(a: A<T>) : T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun test(nothing: Nothing?) {
    val i = infer(<!ARGUMENT_TYPE_MISMATCH!>nothing<!>)
@@ -12,4 +12,4 @@ fun test(nothing: Nothing?) {
 fun sum(a : IntArray) : Int {
 for (n
 <!SYNTAX!>return<!><!SYNTAX!><!> "?"
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -1,3 +1,5 @@
+// COMPARE_WITH_LIGHT_TREE
+
 package sum

 import java.util.*
@@ -6,7 +8,7 @@ fun sum(a : IntArray) : Int {
    <!UNRESOLVED_REFERENCE!>res<!> = 0
    for (e in a)
        <!UNRESOLVED_REFERENCE, VARIABLE_EXPECTED!>res<!> +=<!SYNTAX!><!>
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY{LT}!>}<!>
 fun main() {
    test(0)
    test(1, 1)
@@ -27,4 +29,4 @@ fun <T: Any> assertEquals(actual : T?, expected : T?, message : Any? = null) {
        else
            throw AssertionError(message)
    }
-}
+}
@@ -1,3 +1,5 @@
+// COMPARE_WITH_LIGHT_TREE
+
 package sum

 import java.util.*
@@ -268,7 +268,7 @@ class Main<L>(x: L?, y: L) {
 }

 fun <T : Comparable<T>> nullsLast() = null as Foo<T?>
-fun <K> take(x: Foo<K>, comparator: Foo<K>): Foo<K> {}
+fun <K> take(x: Foo<K>, comparator: Foo<K>): Foo<K> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun <L> test() {
    take(null as Foo<String?>, nullsLast())
 }
@@ -1,14 +0,0 @@
-package b
-//+JDK
-
-import java.util.*
-import java.util.Collections.*
-
-fun foo(list: List<String>) : String {
-    val w : String = max(list, comparator<String?> {o1, o2 -> 1
-    })
-    return w
-}
-
-//from library
-fun <T> comparator(fn: (T,T) -> Int): Comparator<T> {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package b
 //+JDK

@@ -31,6 +31,6 @@ fun foo() {
@Suppress("UNCHECKED_CAST")
 fun <T> array(vararg t : T) : Array<T> = t as Array<T>

-infix fun <T, R> Array<T>.map(transform : (T) -> R) : List<R> {}
+infix fun <T, R> Array<T>.map(transform : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-infix fun <T, R> Iterable<T>.map(transform : (T) -> R) : List<R> {}
+infix fun <T, R> Iterable<T>.map(transform : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -6,8 +6,8 @@ package i
 import java.util.*
 import checkSubtype

-fun <T, R> Collection<T>.map1(f : (T) -> R) : List<R> {}
-fun <T, R> java.lang.Iterable<T>.map1(f : (T) -> R) : List<R> {}
+fun <T, R> Collection<T>.map1(f : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+fun <T, R> java.lang.Iterable<T>.map1(f : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun test(list: List<Int>) {
    val res = list.map1 { it }
@@ -2,7 +2,7 @@ package a

 import java.util.*

-fun <T> g (f: () -> List<T>) : T {}
+fun <T> g (f: () -> List<T>) : T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun test() {
    //here possibly can be a cycle on constraints
@@ -1,19 +0,0 @@
-// !CHECK_TYPE
-
-//KT-1029 Wrong type inference
-package i
-
-import checkSubtype
-
-public fun<T> from(yielder: ()->Iterable<T>) : Iterable<T> {
-}
-
-public infix fun<T> Iterable<T>.where(predicate : (T)->Boolean) : ()->Iterable<T> {
-}
-
-fun a() {
-    val x = 0..200
-    val odd = from (x where {it%2==0}) // I believe it should infer here
-
-    checkSubtype<Iterable<Int>>(odd)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 //KT-1029 Wrong type inference
@@ -1,22 +0,0 @@
-// !CHECK_TYPE
-
-//KT-1031 Can't infer type of `it` with two lambdas
-package i
-
-import java.util.ArrayList
-import checkSubtype
-
-public infix fun<TItem> Iterable<TItem>.where(predicate : (TItem)->Boolean) : ()->Iterable<TItem> {
-}
-
-public fun<TItem, TResult> select(yielder: ()->Iterable<TItem>, selector : (TItem)->TResult) : ()->Iterable<TResult> {
-}
-
-fun a() {
-    val x = 0..200
-    val z = x where { i: Int -> i % 2 == 0 }
-    val yielder = select(x where { it%2==0 }, { it.toString() })
-
-    checkSubtype<() -> Iterable<Int>>(z)
-    checkSubtype<() -> Iterable<String>>(yielder)
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 //KT-1031 Can't infer type of `it` with two lambdas
@@ -2,7 +2,7 @@

 package d

-fun <T> asList(t: T) : List<T>? {}
+fun <T> asList(t: T) : List<T>? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun main() {
    val list : List<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>asList("")<!>
@@ -12,6 +12,6 @@ fun test(numbers: Iterable<Int>) {
 }

 //from library
-fun <T, R> Iterable<T>.map(transform : (T) -> R) : List<R> {}
+fun <T, R> Iterable<T>.map(transform : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-fun <T> Iterable<T>.fold(initial: T, operation: (T, T) -> T): T {}
+fun <T> Iterable<T>.fold(initial: T, operation: (T, T) -> T): T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -1,28 +0,0 @@
-// !CHECK_TYPE
-
-// KT-1410 Compiler does automatically infer type argument when using variance
-//+JDK
-package d
-
-import checkSubtype
-
-public fun <T> MutableCollection<out T>.filterToMy(result : MutableList<in T>, filter : (T) -> Boolean) : MutableCollection<out T> {
-    for (t in this){
-        if (filter(t)){
-            result.add(t)
-        }
-    }
-    return this
-}
-
-fun foo(result: MutableList<in String>, collection: MutableCollection<String>, prefix : String){
-    collection.filterToMy(result, {it.startsWith(prefix)})
-}
-
-fun test(result: MutableList<in Any>, collection: MutableCollection<String>, prefix : String){
-    val c = collection.filterToMy(result, {it.startsWith(prefix)})
-    checkSubtype<MutableCollection<out String>>(c)
-}
-
-//from library
-fun String.startsWith(prefix: String) : Boolean {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 // KT-1410 Compiler does automatically infer type argument when using variance
@@ -14,5 +14,5 @@ fun test() {
 }

 //from library
-fun <T> arrayList(vararg values: T) : ArrayList<T> {}
-operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T> {}
+fun <T> arrayList(vararg values: T) : ArrayList<T> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -24,4 +24,4 @@ abstract class Buggy {
 }

 //from library
-fun <T: Any> Iterable<T>.find(predicate: (T) -> Boolean) : T? {}
+fun <T: Any> Iterable<T>.find(predicate: (T) -> Boolean) : T? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -12,8 +12,8 @@ fun test() {
 }

 //from library
-fun <T> arrayList(vararg values: T) : ArrayList<T> {}
+fun <T> arrayList(vararg values: T) : ArrayList<T> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-fun <T, R> Collection<T>.map(transform : (T) -> R) : List<R> {}
+fun <T, R> Collection<T>.map(transform : (T) -> R) : List<R> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

-fun <T> Iterable<T>.fold(initial: T, operation: (T, T) -> T): T {}
+fun <T> Iterable<T>.fold(initial: T, operation: (T, T) -> T): T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -1,10 +0,0 @@
-//KT-2459 Type inference error
-package b
-
-import java.util.*
-
-class B<T>(val x: List<T>)
-fun <T> f(x: T): B<T> = B(arrayList(x))
-
-// from standard library
-fun <T> arrayList(vararg values: T) : ArrayList<T> {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-2459 Type inference error
 package b

@@ -1,27 +0,0 @@
-package c
-
-interface A<T>
-
-fun test(a: A<Int>?) {
-    a<!UNSAFE_CALL!>.<!>foo() //no error
-}
-
-fun <R> A<R>.foo() {}
-
-//------------
-fun test(nullabilityInfoMap: Map<Int, Any>?) {
-    nullabilityInfoMap<!UNSAFE_CALL!>.<!>iterator() //no error
-}
-
-//resolves to
-public fun <K,V> Map<K,V>.iterator(): Iterator<Map.Entry<K,V>> {}
-
-
-//-------------
-fun foo() : Boolean {
-    val nullableList = getNullableList()
-    return nullableList<!UNSAFE_CALL!>.<!>contains("")
-
-}
-
-fun getNullableList(): List<String>? = null
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package c

 interface A<T>
@@ -8,7 +8,7 @@ class Y<TItem>(val itemToString: (TItem) -> String){
 }

 fun <TItem> bar(context : Y<TItem>) : TItem{
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun foo(){
    val stringToString : (String) -> String = { it }
@@ -1,43 +0,0 @@
-//KT-3007 Kotlin plugin 0.4.126 does not compile KAnnotator revision ba0a93eb
-package a
-
-enum class SomeEnum {
-    FIRST,
-    SECOND
-}
-
-// Doesn't work
-fun Iterable<Int>.some() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
-        if (res == SomeEnum.FIRST) SomeEnum.FIRST else SomeEnum.SECOND
-    })
-}
-
-fun tempFun() : SomeEnum {
-    return SomeEnum.FIRST
-}
-
-// Doesn't work
-fun Iterable<Int>.someSimpleWithFun() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
-        tempFun()
-    })
-}
-
-
-// Works
-fun Iterable<Int>.someSimple() {
-    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
-        SomeEnum.FIRST
-    })
-}
-
-// Works
-fun Iterable<Int>.someInt() {
-    this.fold(0, {res : Int, value ->
-        if (res == 0) 1 else 0
-    })
-}
-
-//from standard library
-fun <T,R> Iterable<T>.fold(initial: R, operation: (R, T) -> R): R {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-3007 Kotlin plugin 0.4.126 does not compile KAnnotator revision ba0a93eb
 package a

@@ -1,20 +0,0 @@
-//KT-3301 Inference with several supertypes fails
-
-package arrays
-
-interface A
-interface B
-
-object CAB : A, B
-object DAB : A, B
-
-fun m(args : Array<A>) {
-
-}
-
-fun test122() {
-    m(array(CAB, DAB)) // Wrong error here: Array<Any> is inferred while expected Array<A> is satisfied
-}
-
-//from library
-fun <T> array(vararg t: T): Array<T> {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-3301 Inference with several supertypes fails

 package arrays
@@ -2,7 +2,7 @@
 package a
 //+JDK

-fun <T> getJavaClass() : java.lang.Class<T> { }
+fun <T> getJavaClass() : java.lang.Class<T> { <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 public class Throwables() {
    companion object {
@@ -1,23 +0,0 @@
-// !CHECK_TYPE
-
-//KT-943 Type inference failed
-package maze
-
-//+JDK
-import java.util.Collections.*
-import java.util.*
-import checkSubtype
-
-fun foo(lines: List<String>) {
-    val w = max(lines, comparator {o1, o2 ->
-        val l1 : Int = o1.length // Types of o1 and o2 are ERROR
-        val l2 = o2.length
-        l1 - l2
-    }).sure()
-    checkSubtype<String>(w)
-}
-
-//standard library
-fun <T : Any> T?.sure() : T = this!!
-
-public inline fun <T> comparator(fn: (T,T) -> Int): Comparator<T> {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 //KT-943 Type inference failed
@@ -1,12 +0,0 @@
-package a
-
-fun <R> foo (f: ()->R, r: MutableList<R>) = r.add(f())
-fun <R> bar (r: MutableList<R>, f: ()->R) = r.add(f())
-
-fun test() {
-    val a = foo({1}, arrayListOf("")) //no type inference error on 'arrayListOf'
-    val b = bar(arrayListOf(""), {1})
-}
-
-// from standard library
-fun <T> arrayListOf(vararg values: T) : MutableList<T> {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package a

 fun <R> foo (f: ()->R, r: MutableList<R>) = r.add(f())
@@ -19,4 +19,4 @@ fun test(a: Any, s: MutableSet<String>) {
 }

 //from standard library
-fun <T> arrayListOf(vararg t: T): MutableList<T> {}
+fun <T> arrayListOf(vararg t: T): MutableList<T> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -150,7 +150,7 @@ fun illegalWhenBlock(a: Any): Int {
        is Int -> return a
        is String -> return <!RETURN_TYPE_MISMATCH!>a<!>
    }
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun declarations(a: Any?) {
    if (a is String) {
       val p4: String = a
@@ -107,4 +107,4 @@ fun <K, V> testMutableMap(m: MutableMap<K, V>) {
    val mutableSet1: MutableSet<MutableMap.MutableEntry<K, V>> = m.entries
 }

-fun <T> array(vararg t: T): Array<T> {}
+fun <T> array(vararg t: T): Array<T> {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
@@ -1,8 +0,0 @@
-package kt402
-
-fun getTypeChecker() : (Any)->Boolean {
-  { a : Any -> a is <!UNRESOLVED_REFERENCE!>T<!> } // reports unsupported
-}
-fun f() : (Any) -> Boolean {
-  return { a : Any -> a is String }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package kt402

 fun getTypeChecker() : (Any)->Boolean {
@@ -1,31 +0,0 @@
-// KT-442 Type inference fails on with()
-
-fun <T> funny(f : () -> T) : T = f()
-
-fun testFunny() {
-    val a : Int = funny {1}
-}
-
-fun <T> funny2(f : (t : T) -> T) : T {}
-
-fun testFunny2() {
-    val a : Int = funny2 {it}
-}
-
-fun box() : String {
-    return generic_invoker { it }
-}
-
-fun <T> generic_invoker(gen :  (String) -> T) : T {
-    return gen("")
-}
-
-infix fun <T> T.with(f :  T.() -> Unit) {
-    f()
-}
-
-fun main() {
-    val a = 1 with {
-        plus(1)
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-442 Type inference fails on with()

 fun <T> funny(f : () -> T) : T = f()
@@ -1,30 +0,0 @@
-//KT-456 No check for obligatory return in getters
-
-package kt456
-
-class A() {
-    val i: Int
-    get() : Int {  //no error
-    }
-}
-
-//more tests
-class B() {
-    val i: Int
-    get() {  //no error
-    }
-}
-
-class C() {
-    val i : Int
-    get() : Int {
-        try {
-            doSmth()
-        }
-        finally {
-            doSmth()
-        }
-    }
-}
-
-fun doSmth() {}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-456 No check for obligatory return in getters

 package kt456
@@ -85,7 +85,7 @@ fun t7() : Int {
    finally {
        doSmth(3)
    }
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun doSmth(i: Int) {
 }
@@ -3,7 +3,7 @@ data class StringPair(val first: String, val second: String)
 infix fun String.to(second: String) = StringPair(this, second)

 fun hashMapOf(pair: StringPair): MutableMap<String, String> {
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun F() : MutableMap<String, String> {
    val value: String? = "xyz"
@@ -14,10 +14,10 @@ fun bad(): String {
    val x: String? = null

    x?.myRun { return "" }
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun ok(): String {
    val x: String? = null

    x?.run { return "non-null" } ?: return "null"
-}
+<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>