Support local return in lambda without explicit return type

compiler/testData/diagnostics/tests/functionLiterals/return/IfInReturnedExpression.kt

@@ -0,0 +1,5 @@
+val flag = true
+
+val a/*: () -> Comparable<out Any?>*/ = @l {
+    return@l if (flag) "OK" else 4
+}

compiler/testData/diagnostics/tests/functionLiterals/return/IfInReturnedExpression.txt

@@ -0,0 +1,4 @@
+package
+
+internal val a: () -> kotlin.Comparable<out kotlin.Any?>
+internal val flag: kotlin.Boolean = true

compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt

@@ -0,0 +1,15 @@
+val flag = true
+
+// type of a was checked by txt
+val a/*: () -> Any*/ = @l { // commonSupertype(Int, Unit) = Any
+    if (flag) return@l 4
+}
+
+val b/*: () -> Int */ = @l {
+    if (flag) return@l 4
+    5
+}
+
+val c/*: () -> Unit */ = @l {
+    if (flag) <!UNUSED_EXPRESSION!>4<!>
+}

compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.txt

@@ -0,0 +1,6 @@
+package
+
+internal val a: () -> kotlin.Any
+internal val b: () -> kotlin.Int
+internal val c: () -> kotlin.Unit
+internal val flag: kotlin.Boolean = true

compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt

@@ -0,0 +1,22 @@
+val flag = true
+
+val a: () -> Int = @l {
+    <!TYPE_MISMATCH!>if (flag) return@l 4<!>
+}
+
+val b: () -> Unit = @l {
+    if (flag) return@l <!CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
+}
+
+val c: () -> Any = @l {
+    if (flag) return@l 4
+}
+
+val d: () -> Int = @l {
+    if (flag) return@l 4
+    5
+}
+
+val e: () -> Int = @l {
+    <!TYPE_MISMATCH!>if (flag) <!UNUSED_EXPRESSION!>4<!><!>
+}

compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.txt

@@ -0,0 +1,8 @@
+package
+
+internal val a: () -> kotlin.Int
+internal val b: () -> kotlin.Unit
+internal val c: () -> kotlin.Any
+internal val d: () -> kotlin.Int
+internal val e: () -> kotlin.Int
+internal val flag: kotlin.Boolean = true

compiler/testData/diagnostics/tests/functionLiterals/return/LambdaWithParameter.kt

@@ -0,0 +1,17 @@
+val flag = true
+
+val a /*: (Int) -> String */ = @l {
+    (i: Int) ->
+    if (i == 0) return@l i.toString()
+
+    "Ok"
+}
+
+fun <T> foo(f: (Int) -> T): T = f(0)
+
+val b /*:String */ = foo {
+    (i) ->
+    if (i == 0) return@foo i.toString()
+
+    "Ok"
+}

compiler/testData/diagnostics/tests/functionLiterals/return/LambdaWithParameter.txt

@@ -0,0 +1,6 @@
+package
+
+internal val a: (kotlin.Int) -> kotlin.String
+internal val b: kotlin.String
+internal val flag: kotlin.Boolean = true
+internal fun </*0*/ T> foo(/*0*/ f: (kotlin.Int) -> T): T

compiler/testData/diagnostics/tests/functionLiterals/return/LocalAndNonLocalReturnInLambda.kt

@@ -1,7 +1,7 @@
 fun test2(a: Int) {
     val x = run @f{
       if (a > 0) <!RETURN_NOT_ALLOWED!>return<!>
-      <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f 1<!>
+      return@f 1
     }
     x: Int
 }

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelNoParens.kt

@@ -1,5 +1,5 @@
 fun test2() {
-    val x = run @f{<!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f 1<!>}
+    val x = run @f{return@f 1}
     x: Int
 }
 

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelParens.kt

@@ -1,11 +1,11 @@
 fun test() {
-    val x = run(@f{<!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f 1<!>})
+    val x = run(@f{return@f 1})
     x: Int
 }
 
 
 fun test1() {
-    val x = run(@l{<!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@l 1<!>})
+    val x = run(@l{return@l 1})
     x: Int
 }
 

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedFunction.kt

@@ -4,7 +4,7 @@ fun test() {
         if (a > 0) return "2"
         return@local "3"
       }
-      <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f 1<!>
+      return@f 1
     }
     x: Int
 }

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedLambda.kt

@@ -1,9 +1,9 @@
 fun test() {
     val x = run @f{
       run @ff {
-        <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@ff "2"<!>
+        return@ff "2"
       }
-      <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f 1<!>
+      return@f 1
     }
     x: Int
 }

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNoCoercionToUnit.kt

@@ -1,7 +1,7 @@
 fun test(a: Int) {
     run @f{
-      if (a > 0) <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f<!>
-      else <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f 1<!>
+      if (a > 0) <!RETURN_TYPE_MISMATCH!>return@f<!>
+      else return@f 1
     }
 }
 

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNull.kt

@@ -0,0 +1,14 @@
+class A
+val flag = true
+
+val a /*: () -> A?*/ = @l {
+    if (flag) return@l null
+
+    A()
+}
+
+val b /*: () -> A?*/ = @l {
+    if (flag) return@l null
+
+    return@l A()
+}

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNull.txt

@@ -0,0 +1,12 @@
+package
+
+internal val a: () -> A?
+internal val b: () -> A?
+internal val flag: kotlin.Boolean = true
+
+internal final class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnit.kt

@@ -1,9 +1,9 @@
 fun test(a: Int) {
     val x = run @f{
-      if (a > 0) <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f<!>
-      else <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f Unit<!>
+      if (a > 0) <!RETURN_TYPE_MISMATCH!>return@f<!>
+      else return@f Unit
     }
     x: Unit
 }
 
-fun run<T>(f: () -> T): T { return f() }
+fun run<T>(f: () -> T): T { return f() }

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExpectedType.kt

@@ -0,0 +1,9 @@
+fun listOf<T>(): List<T> = null!!
+fun listOf<T>(vararg <!UNUSED_PARAMETER!>values<!>: T): List<T> = null!!
+
+val flag = true
+
+val a: () -> List<Int> = @l {
+    if (flag) return@l listOf()
+    listOf(5)
+}

compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExpectedType.txt

@@ -0,0 +1,6 @@
+package
+
+internal val a: () -> kotlin.List<kotlin.Int>
+internal val flag: kotlin.Boolean = true
+internal fun </*0*/ T> listOf(): kotlin.List<T>
+internal fun </*0*/ T> listOf(/*0*/ vararg values: T /*kotlin.Array<out T>*/): kotlin.List<T>

compiler/testData/diagnostics/tests/functionLiterals/return/MixedReturnsFromLambda.kt

@@ -5,7 +5,7 @@ trait C: A
 
 fun test(a: C, b: B) {
     val x = run @f{
-      if (a != b) <!RETURN_NOT_ALLOWED_EXPLICIT_RETURN_TYPE_REQUIRED!>return@f a<!>
+      if (a != b) return@f a
       b
     }
     x: A

compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt

@@ -0,0 +1,18 @@
+fun <T, R> Iterable<T>.map(<!UNUSED_PARAMETER!>transform<!>: (T) -> R): List<R> = null!!
+fun listOf<T>(): List<T> = null!!
+fun listOf<T>(vararg <!UNUSED_PARAMETER!>values<!>: T): List<T> = null!!
+
+fun commonSystemFailed(a: List<Int>) {
+    a.map {
+        if (it == 0) return@map listOf(it)
+        <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>()
+    }
+    a.map {
+        if (it == 0) return@map <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>listOf<!>()
+        listOf(it)
+    }
+    a.map {
+        if (it == 0) listOf()
+        else listOf(it)
+    }
+}

compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.txt

@@ -0,0 +1,6 @@
+package
+
+internal fun commonSystemFailed(/*0*/ a: kotlin.List<kotlin.Int>): kotlin.Unit
+internal fun </*0*/ T> listOf(): kotlin.List<T>
+internal fun </*0*/ T> listOf(/*0*/ vararg values: T /*kotlin.Array<out T>*/): kotlin.List<T>
+internal fun </*0*/ T, /*1*/ R> kotlin.Iterable<T>.map(/*0*/ transform: (T) -> R): kotlin.List<R>

compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt

@@ -0,0 +1,17 @@
+// KT-6822 Smart cast doesn't work inside local returned expression in lambda 
+
+val a /* :(Int?) -> Int? */ = @l { (it: Int?) -> // but must be (Int?) -> Int
+    if (it != null) return@l it
+    5
+}
+
+fun <R> let(<!UNUSED_PARAMETER!>f<!>: (Int?) -> R): R = null!!
+
+val b /*: Int? */ = let { // but must be Int
+    if (it != null) return@let it
+    5
+}
+
+val c /*: Int*/ = let {
+    if (it != null) <!DEBUG_INFO_SMARTCAST!>it<!> else 5
+}

compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.txt

@@ -0,0 +1,6 @@
+package
+
+internal val a: (kotlin.Int?) -> kotlin.Int?
+internal val b: kotlin.Int?
+internal val c: kotlin.Int
+internal fun </*0*/ R> let(/*0*/ f: (kotlin.Int?) -> R): R

compiler/testData/diagnostics/tests/functionLiterals/return/SmartCastWithExplicitType.kt

@@ -0,0 +1,17 @@
+// KT-6822 Smart cast doesn't work inside local returned expression in lambda
+
+val a : (Int?) -> Int = @l {
+    if (it != null) return@l <!DEBUG_INFO_SMARTCAST!>it<!>
+    5
+}
+
+fun <R> let(<!UNUSED_PARAMETER!>f<!>: (Int?) -> R): R = null!!
+
+val b: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>let<!> {
+    if (it != null) return@let it
+    5
+}
+
+val c: Int = let {
+    if (it != null) <!DEBUG_INFO_SMARTCAST!>it<!> else 5
+}

compiler/testData/diagnostics/tests/functionLiterals/return/SmartCastWithExplicitType.txt

@@ -0,0 +1,6 @@
+package
+
+internal val a: (kotlin.Int?) -> kotlin.Int
+internal val b: kotlin.Int
+internal val c: kotlin.Int
+internal fun </*0*/ R> let(/*0*/ f: (kotlin.Int?) -> R): R

compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt

@@ -0,0 +1,10 @@
+package m
+
+trait Element
+
+fun test(handlers: Map<String, Element.()->Unit>) {
+
+    handlers.getOrElse("name", @l { return@l <!NULL_FOR_NONNULL_TYPE!>null<!> })
+}
+
+fun <K,V> Map<K,V>.getOrElse(key: K, defaultValue: ()-> V) : V = throw Exception("$key $defaultValue")

compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.txt

@@ -0,0 +1,12 @@
+package
+
+package m {
+    internal fun test(/*0*/ handlers: kotlin.Map<kotlin.String, m.Element.() -> kotlin.Unit>): kotlin.Unit
+    internal fun </*0*/ K, /*1*/ V> kotlin.Map<K, V>.getOrElse(/*0*/ key: K, /*1*/ defaultValue: () -> V): V
+
+    internal trait Element {
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}