Report RETURN_NOT_ALLOWED and RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY only on the return with label (KT-13340)

goodwinnk · goodwinnk · commit 300e0acd27da · 2016-08-05T13:16:05.000+03:00
#KT-13340 Fixed
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
@@ -774,8 +774,8 @@ enum BadNamedArgumentsTarget {
 
     DiagnosticFactory0<KtSimpleNameExpression> EXPRESSION_EXPECTED_PACKAGE_FOUND = DiagnosticFactory0.create(ERROR);
 
-    DiagnosticFactory0<KtReturnExpression> RETURN_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
-    DiagnosticFactory0<KtReturnExpression> RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<KtReturnExpression> RETURN_NOT_ALLOWED = DiagnosticFactory0.create(ERROR, PositioningStrategies.RETURN_WITH_LABEL);
+    DiagnosticFactory0<KtReturnExpression> RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY = DiagnosticFactory0.create(ERROR, PositioningStrategies.RETURN_WITH_LABEL);
     DiagnosticFactory0<KtDeclarationWithBody>
             NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_WITH_BODY);
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
@@ -477,4 +477,14 @@ object PositioningStrategies {
         }
     }
 
+    @JvmField val RETURN_WITH_LABEL: PositioningStrategy<KtReturnExpression> = object: PositioningStrategy<KtReturnExpression>() {
+        override fun mark(element: KtReturnExpression): List<TextRange> {
+            val labeledExpression = element.labeledExpression
+            if (labeledExpression != null) {
+                return markRange(element, labeledExpression)
+            }
+
+            return markElement(element.returnKeyword)
+        }
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KtReturnExpression.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/KtReturnExpression.java
@@ -17,8 +17,11 @@
 package org.jetbrains.kotlin.psi;
 
 import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.KtNodeTypes;
+import org.jetbrains.kotlin.lexer.KtTokens;
 
 public class KtReturnExpression extends KtExpressionWithLabel implements KtStatementExpression {
     public KtReturnExpression(@NotNull ASTNode node) {
@@ -34,4 +37,15 @@ public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
     public KtExpression getReturnedExpression() {
         return findChildByClass(KtExpression.class);
     }
+
+    @NotNull
+    public PsiElement getReturnKeyword() {
+        //noinspection ConstantConditions
+        return findChildByType(KtTokens.RETURN_KEYWORD);
+    }
+
+    @Nullable
+    public PsiElement getLabeledExpression() {
+        return findChildByType(KtNodeTypes.LABEL_QUALIFIER);
+    }
 }
diff --git a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
@@ -12,7 +12,7 @@ fun test2() : Any = a@ {return@a 1}
 fun test3() : Any { <!RETURN_TYPE_MISMATCH!>return<!> }
 fun test4(): ()-> Unit = { <!RETURN_NOT_ALLOWED, RETURN_TYPE_MISMATCH!>return@test4<!> }
 fun test5(): Any = l@{ return@l }
-fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return 1<!>}
+fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return<!> 1}
 
 fun bbb() {
   return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
@@ -136,7 +136,7 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
 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<!>
+val a = <!RETURN_NOT_ALLOWED!>return<!> 1
 
 class A() {
 }
diff --git a/compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.kt b/compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.kt
@@ -0,0 +1,3 @@
+fun foo1(): () -> String = <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!> { "some long expression "}
+fun foo2(): () -> String = <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!UNRESOLVED_REFERENCE!>@label<!><!> { "some long expression "}
+fun foo3(): () -> String = <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!><!SYNTAX!>@<!> { "some long expression "}
diff --git a/compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.txt b/compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.txt
@@ -0,0 +1,5 @@
+package
+
+public fun foo1(): () -> kotlin.String
+public fun foo2(): () -> kotlin.String
+public fun foo3(): () -> kotlin.String
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10823.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10823.kt
@@ -1,6 +1,6 @@
 fun find2(): Any? {
     fun visit(element: Any) {
-        <!RETURN_NOT_ALLOWED!>return@find2 element<!>
+        <!RETURN_NOT_ALLOWED!>return@find2<!> element
     }
     return null
 }
@@ -10,23 +10,23 @@ fun find2(): Any? {
 fun find(): Any? {
     object : Any() {
         fun visit(element: Any) {
-            <!RETURN_NOT_ALLOWED!>return@find element<!>
+            <!RETURN_NOT_ALLOWED!>return@find<!> element
         }
     }
     return null
 }
 
 fun find4(): Any? {
     <!NOT_YET_SUPPORTED_IN_INLINE!>inline fun visit(element: Any) {
-        <!RETURN_NOT_ALLOWED!>return@find4 element<!>
+        <!RETURN_NOT_ALLOWED!>return@find4<!> element
     }<!>
     return null
 }
 
 fun find3(): Any? {
     object : Any() {
         <!NOTHING_TO_INLINE!>inline<!> fun visit(element: Any) {
-            <!RETURN_NOT_ALLOWED!>return@find3 element<!>
+            <!RETURN_NOT_ALLOWED!>return@find3<!> element
         }
     }
     return null
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt799.kt b/compiler/testData/diagnostics/tests/controlStructures/kt799.kt
@@ -12,9 +12,9 @@ fun test() {
     doSmth(if (true) 3 else return, <!TOO_MANY_ARGUMENTS!>1<!>)
 }
 
-val a : Nothing = <!RETURN_NOT_ALLOWED!>return 1<!>
+val a : Nothing = <!RETURN_NOT_ALLOWED!>return<!> 1
 
-val b = <!RETURN_NOT_ALLOWED!>return 1<!>
+val b = <!RETURN_NOT_ALLOWED!>return<!> 1
 
 val c = doSmth(if (true) 3 else <!RETURN_NOT_ALLOWED!>return<!>)
 
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.kt b/compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.kt
@@ -1,34 +1,34 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
 // KT-5068 Add special error for scala-like syntax 'fun foo(): Int = { 1 }'
 
-fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
 fun test2(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
-val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
 val test4: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
 fun test5(): Int { return <!TYPE_MISMATCH!>{ 1 }<!> }
 fun test6(): Int = <!TYPE_MISMATCH!>fun (): Int = 1<!>
 
 fun outer() {
-    fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+    fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
     fun test2(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
-    val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+    val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
     val test4: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
     fun test5(): Int { return <!TYPE_MISMATCH!>{ 1 }<!> }
     fun test6(): Int = <!TYPE_MISMATCH!>fun (): Int = 1<!>
 }
 
 class Outer {
-    fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+    fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
     fun test2(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
-    val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+    val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
     val test4: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
     fun test5(): Int { return <!TYPE_MISMATCH!>{ 1 }<!> }
     fun test6(): Int = <!TYPE_MISMATCH!>fun (): Int = 1<!>
 
     class Nested {
-        fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+        fun test1(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
         fun test2(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
-        val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return 1<!> }<!>
+        val test3: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
         val test4: () -> Int = fun (): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1 }<!>
         fun test5(): Int { return <!TYPE_MISMATCH!>{ 1 }<!> }
         fun test6(): Int = <!TYPE_MISMATCH!>fun (): Int = 1<!>
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabelsNonLocal.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabelsNonLocal.kt
@@ -1,7 +1,7 @@
 fun f() {
     foo {
         bar {
-            <!RETURN_NOT_ALLOWED!>return@foo 1<!>
+            <!RETURN_NOT_ALLOWED!>return@foo<!> 1
         }
         return@foo 1
     }
diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.kt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.kt
@@ -17,7 +17,7 @@ inline fun inlineFun(s: ()->Int) {
 fun noInlineCall(): String {
     noInline {
         if (true) {
-            <!RETURN_NOT_ALLOWED!>return@noInlineCall ""<!>
+            <!RETURN_NOT_ALLOWED!>return@noInlineCall<!> ""
         }
         1
     }
diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt
@@ -1,6 +1,6 @@
 fun box() : String {
     test {
-        <!RETURN_NOT_ALLOWED!>return@box "123"<!>
+        <!RETURN_NOT_ALLOWED!>return@box<!> "123"
     }
 
     return "OK"
diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.kt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.kt
@@ -1,6 +1,6 @@
 fun box() : String {
     test {
-        <!RETURN_NOT_ALLOWED!>return@box "123"<!>
+        <!RETURN_NOT_ALLOWED!>return@box<!> "123"
     }
 
     return "OK"
diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.kt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.kt
@@ -7,7 +7,7 @@ inline fun <R> doCallInt(p: () -> R): R {
 }
 
 class A {
-    var result: Int = doCallInt { <!RETURN_NOT_ALLOWED!>return this<!> };
+    var result: Int = doCallInt { <!RETURN_NOT_ALLOWED!>return<!> this };
 
     var field: Int
         get() {
diff --git a/compiler/testData/diagnostics/tests/labels/kt361.kt b/compiler/testData/diagnostics/tests/labels/kt361.kt
@@ -2,7 +2,7 @@ fun nonlocals(b : Boolean) {
     a@<!UNUSED_LAMBDA_EXPRESSION!>{
         fun foo() {
             if (b) {
-                <!RETURN_NOT_ALLOWED!>return@a 1<!> // The label must be resolved, but an error should be reported for a non-local return
+                <!RETURN_NOT_ALLOWED!>return@a<!> 1 // The label must be resolved, but an error should be reported for a non-local return
             }
         }
 
diff --git a/compiler/testData/diagnostics/tests/regressions/kt411.kt b/compiler/testData/diagnostics/tests/regressions/kt411.kt
@@ -23,7 +23,7 @@ fun t2() : String {
         if (true) {
             return@l 1
         }
-        <!RETURN_NOT_ALLOWED!>return "s"<!>
+        <!RETURN_NOT_ALLOWED!>return<!> "s"
     }
     return "s"
 }
@@ -32,10 +32,10 @@ fun t3() : String {
     invoker(
     l@{
         if (true) {
-            <!RETURN_NOT_ALLOWED!>return@t3 "1"<!>
+            <!RETURN_NOT_ALLOWED!>return@t3<!> "1"
         }
         else {
-            <!RETURN_NOT_ALLOWED!>return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>
+            <!RETURN_NOT_ALLOWED!>return<!> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>
         }
         <!UNREACHABLE_CODE!>return@l 0<!>
     }
@@ -47,7 +47,7 @@ fun t3() : String {
     )
     invoker(
     {
-        <!RETURN_NOT_ALLOWED!>return "0"<!>
+        <!RETURN_NOT_ALLOWED!>return<!> "0"
     }
     )
     return "2"
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt
@@ -1,7 +1,7 @@
 class A {
     init {
         <!RETURN_NOT_ALLOWED!>return<!>
-        <!RETURN_NOT_ALLOWED, UNREACHABLE_CODE!>return 1<!>
+        <!UNREACHABLE_CODE!><!RETURN_NOT_ALLOWED!>return<!> 1<!>
     }
     constructor() <!UNREACHABLE_CODE!>{
         if (1 == 1) {
diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
@@ -589,6 +589,12 @@ public void testReturn() throws Exception {
             doTest(fileName);
         }
 
+        @TestMetadata("ReturnInFunctionWithoutBody.kt")
+        public void testReturnInFunctionWithoutBody() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("SafeCallInvoke.kt")
         public void testSafeCallInvoke() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SafeCallInvoke.kt");
diff --git a/idea/testData/checker/FunctionReturnTypes.kt b/idea/testData/checker/FunctionReturnTypes.kt
@@ -131,7 +131,7 @@ fun blockNoReturnIfUnitInOneBranch(): Int {
 fun nonBlockReturnIfEmptyIf(): Int = if (1 < 2) <error>{}</error> else <error>{}</error>
 fun nonBlockNoReturnIfUnitInOneBranch(): Int = if (1 < 2) <error>{}</error> else 2
 
-val a = <error>return 1</error>
+val a = <error>return</error> 1
 
 class A() {
 }
diff --git a/idea/testData/checker/codeFragments/startingFromReturn.kt.fragment b/idea/testData/checker/codeFragments/startingFromReturn.kt.fragment
@@ -1 +1 @@
-<error descr="[RETURN_NOT_ALLOWED] 'return' is not allowed here">return a</error>
+<error descr="[RETURN_NOT_ALLOWED] 'return' is not allowed here">return</error> a
diff --git a/idea/testData/checker/recovery/returnInFileAnnotation.kt b/idea/testData/checker/recovery/returnInFileAnnotation.kt
@@ -1 +1 @@
-@file:<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: suppress">suppress</error>(<error descr="[RETURN_NOT_ALLOWED] 'return' is not allowed here"><error descr="[RETURN_NOT_ALLOWED] 'return' is not allowed here">return <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: a"><error descr="[UNRESOLVED_REFERENCE] Unresolved reference: a">a</error></error></error></error>)
+@file:<error descr="[UNRESOLVED_REFERENCE] Unresolved reference: suppress">suppress</error>(<error descr="[RETURN_NOT_ALLOWED] 'return' is not allowed here"><error descr="[RETURN_NOT_ALLOWED] 'return' is not allowed here">return</error></error> <error descr="[UNRESOLVED_REFERENCE] Unresolved reference: a"><error descr="[UNRESOLVED_REFERENCE] Unresolved reference: a">a</error></error>)

Original file line number	Diff line number	Diff line change
`@@ -477,4 +477,14 @@ object PositioningStrategies {`
`477`	`477`	`}`
`478`	`478`	`}`
`479`	`479`
	`480`	`+ @JvmField val RETURN_WITH_LABEL: PositioningStrategy<KtReturnExpression> = object: PositioningStrategy<KtReturnExpression>() {`
	`481`	`+ override fun mark(element: KtReturnExpression): List<TextRange> {`
	`482`	`+ val labeledExpression = element.labeledExpression`
	`483`	`+ if (labeledExpression != null) {`
	`484`	`+ return markRange(element, labeledExpression)`
	`485`	`+ }`
	`486`	`+`
	`487`	`+ return markElement(element.returnKeyword)`
	`488`	`+ }`
	`489`	`+ }`
`480`	`490`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+fun foo1(): () -> String = <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!> { "some long expression "}`
	`2`	`+fun foo2(): () -> String = <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!UNRESOLVED_REFERENCE!>@label<!><!> { "some long expression "}`
	`3`	`+fun foo3(): () -> String = <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!><!SYNTAX!>@<!> { "some long expression "}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`fun find2(): Any? {`
`2`	`2`	`fun visit(element: Any) {`
`3`		`- <!RETURN_NOT_ALLOWED!>return@find2 element<!>`
	`3`	`+ <!RETURN_NOT_ALLOWED!>return@find2<!> element`
`4`	`4`	`}`
`5`	`5`	`return null`
`6`	`6`	`}`
`@@ -10,23 +10,23 @@ fun find2(): Any? {`
`10`	`10`	`fun find(): Any? {`
`11`	`11`	`object : Any() {`
`12`	`12`	`fun visit(element: Any) {`
`13`		`- <!RETURN_NOT_ALLOWED!>return@find element<!>`
	`13`	`+ <!RETURN_NOT_ALLOWED!>return@find<!> element`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`	`return null`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`fun find4(): Any? {`
`20`	`20`	`<!NOT_YET_SUPPORTED_IN_INLINE!>inline fun visit(element: Any) {`
`21`		`- <!RETURN_NOT_ALLOWED!>return@find4 element<!>`
	`21`	`+ <!RETURN_NOT_ALLOWED!>return@find4<!> element`
`22`	`22`	`}<!>`
`23`	`23`	`return null`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`fun find3(): Any? {`
`27`	`27`	`object : Any() {`
`28`	`28`	`<!NOTHING_TO_INLINE!>inline<!> fun visit(element: Any) {`
`29`		`- <!RETURN_NOT_ALLOWED!>return@find3 element<!>`
	`29`	`+ <!RETURN_NOT_ALLOWED!>return@find3<!> element`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`return null`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ fun test() {`
`12`	`12`	`doSmth(if (true) 3 else return, <!TOO_MANY_ARGUMENTS!>1<!>)`
`13`	`13`	`}`
`14`	`14`
`15`		`-val a : Nothing = <!RETURN_NOT_ALLOWED!>return 1<!>`
	`15`	`+val a : Nothing = <!RETURN_NOT_ALLOWED!>return<!> 1`
`16`	`16`
`17`		`-val b = <!RETURN_NOT_ALLOWED!>return 1<!>`
	`17`	`+val b = <!RETURN_NOT_ALLOWED!>return<!> 1`
`18`	`18`
`19`	`19`	`val c = doSmth(if (true) 3 else <!RETURN_NOT_ALLOWED!>return<!>)`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`fun f() {`
`2`	`2`	`foo {`
`3`	`3`	`bar {`
`4`		`- <!RETURN_NOT_ALLOWED!>return@foo 1<!>`
	`4`	`+ <!RETURN_NOT_ALLOWED!>return@foo<!> 1`
`5`	`5`	`}`
`6`	`6`	`return@foo 1`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ inline fun inlineFun(s: ()->Int) {`
`17`	`17`	`fun noInlineCall(): String {`
`18`	`18`	`noInline {`
`19`	`19`	`if (true) {`
`20`		`- <!RETURN_NOT_ALLOWED!>return@noInlineCall ""<!>`
	`20`	`+ <!RETURN_NOT_ALLOWED!>return@noInlineCall<!> ""`
`21`	`21`	`}`
`22`	`22`	`1`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`fun box() : String {`
`2`	`2`	`test {`
`3`		`- <!RETURN_NOT_ALLOWED!>return@box "123"<!>`
	`3`	`+ <!RETURN_NOT_ALLOWED!>return@box<!> "123"`
`4`	`4`	`}`
`5`	`5`
`6`	`6`	`return "OK"`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ inline fun <R> doCallInt(p: () -> R): R {`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`class A {`
`10`		`- var result: Int = doCallInt { <!RETURN_NOT_ALLOWED!>return this<!> };`
	`10`	`+ var result: Int = doCallInt { <!RETURN_NOT_ALLOWED!>return<!> this };`
`11`	`11`
`12`	`12`	`var field: Int`
`13`	`13`	`get() {`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ fun nonlocals(b : Boolean) {`
`2`	`2`	`a@<!UNUSED_LAMBDA_EXPRESSION!>{`
`3`	`3`	`fun foo() {`
`4`	`4`	`if (b) {`
`5`		`- <!RETURN_NOT_ALLOWED!>return@a 1<!> // The label must be resolved, but an error should be reported for a non-local return`
	`5`	`+ <!RETURN_NOT_ALLOWED!>return@a<!> 1 // The label must be resolved, but an error should be reported for a non-local return`
`6`	`6`	`}`
`7`	`7`	`}`
`8`	`8`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ fun t2() : String {`
`23`	`23`	`if (true) {`
`24`	`24`	`return@l 1`
`25`	`25`	`}`
`26`		`- <!RETURN_NOT_ALLOWED!>return "s"<!>`
	`26`	`+ <!RETURN_NOT_ALLOWED!>return<!> "s"`
`27`	`27`	`}`
`28`	`28`	`return "s"`
`29`	`29`	`}`
`@@ -32,10 +32,10 @@ fun t3() : String {`
`32`	`32`	`invoker(`
`33`	`33`	`l@{`
`34`	`34`	`if (true) {`
`35`		`- <!RETURN_NOT_ALLOWED!>return@t3 "1"<!>`
	`35`	`+ <!RETURN_NOT_ALLOWED!>return@t3<!> "1"`
`36`	`36`	`}`
`37`	`37`	`else {`
`38`		`- <!RETURN_NOT_ALLOWED!>return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>`
	`38`	`+ <!RETURN_NOT_ALLOWED!>return<!> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>`
`39`	`39`	`}`
`40`	`40`	`<!UNREACHABLE_CODE!>return@l 0<!>`
`41`	`41`	`}`
`@@ -47,7 +47,7 @@ fun t3() : String {`
`47`	`47`	`)`
`48`	`48`	`invoker(`
`49`	`49`	`{`
`50`		`- <!RETURN_NOT_ALLOWED!>return "0"<!>`
	`50`	`+ <!RETURN_NOT_ALLOWED!>return<!> "0"`
`51`	`51`	`}`
`52`	`52`	`)`
`53`	`53`	`return "2"`