Adjust testData to new labels syntax

2015-04-27 14:39:46 +03:00
parent 5977302465
commit 44a55e5bf6
191 changed files with 747 additions and 747 deletions
@@ -1,8 +1,8 @@
 class C {

    fun f (<!UNUSED_PARAMETER!>a<!> : Boolean, <!UNUSED_PARAMETER!>b<!> : Boolean) {
-        @b while (true)
-          @a {
+        b@ while (true)
+          a@ {
            <!NOT_A_LOOP_LABEL!>break@f<!>
            break
            <!UNREACHABLE_CODE!>break@b<!>
@@ -11,8 +11,8 @@ class C {

        <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>

-        @b while (true)
-          @a {
+        b@ while (true)
+          a@ {
            <!NOT_A_LOOP_LABEL!>continue@f<!>
            continue
            <!UNREACHABLE_CODE!>continue@b<!>
@@ -42,21 +42,21 @@ class C {
    }

    fun containsBreakWithLabel(a: String?) {
-        @loop while(a == null) {
+        loop@ while(a == null) {
            break@loop
        }
        a?.compareTo("2")
    }

    fun containsIllegalBreak(a: String?) {
-        @loop while(a == null) {
+        loop@ while(a == null) {
            <!NOT_A_LOOP_LABEL!>break<!UNRESOLVED_REFERENCE!>@label<!><!>
        }
        <!DEBUG_INFO_SMARTCAST!>a<!>.compareTo("2")
    }

    fun containsBreakToOuterLoop(a: String?, b: String?) {
-        @loop while(b == null) {
+        loop@ while(b == null) {
            while(a == null) {
                break@loop
            }
@@ -65,7 +65,7 @@ class C {
    }

    fun containsBreakInsideLoopWithLabel(a: String?, array: Array<Int>) {
-        @l while(a == null) {
+        l@ while(a == null) {
            for (el in array) {
                break@l
            }
@@ -75,7 +75,7 @@ class C {

    fun unresolvedBreak(a: String?, array: Array<Int>) {
        while(a == null) {
-            @l for (el in array) {
+            l@ for (el in array) {
                break
            }
            if (true) break else <!NOT_A_LOOP_LABEL!>break<!UNRESOLVED_REFERENCE!>@l<!><!>
@@ -46,7 +46,7 @@ fun breakContinueInWhenWithDoWhile(i: Int, j: Int) {
 }

 fun labeledBreakContinue(i: Int) {
-    @outer for (y in 0..10) {
+    outer@ for (y in 0..10) {
        when (i) {
            0 -> continue@outer
            1 -> break@outer
@@ -56,7 +56,7 @@ fun main1() {
    {1}();
    (fun (x : Int) = x)(1)
    1.(fun Int.(x : Int) = x)(1);
-    @l{1}()
+    l@{1}()
    1.((fun Int.() = 1))()
    1.(f())()
    1.if(true){f()}else{f()}()
@@ -8,10 +8,10 @@ fun unitEmptyReturn() : Unit {return}
 fun unitIntReturn() : Unit {return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>}
 fun unitUnitReturn() : Unit {return Unit}
 fun test1() : Any = {<!RETURN_NOT_ALLOWED, RETURN_TYPE_MISMATCH!>return<!>}
-fun test2() : Any = @a {return@a 1}
+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 test5(): Any = l@{ return@l }
 fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return 1<!>}

 fun bbb() {
@@ -54,17 +54,17 @@ fun cannotBe() {
 fun canBe(i0: Int, j: Int) {
    var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>i<!> = i0
    (i: Int) = <!UNUSED_VALUE!>36<!>
-    (@label i) = <!UNUSED_VALUE!>34<!>
+    (label@ i) = <!UNUSED_VALUE!>34<!>

    (<!VAL_REASSIGNMENT!>j<!>: Int) = <!UNUSED_VALUE!>36<!>
-    (@label j) = <!UNUSED_VALUE!>34<!> //repeat for j
+    (label@ j) = <!UNUSED_VALUE!>34<!> //repeat for j

    val a = A()
-    (@l a.a) = 3894
+    (l@ a.a) = 3894
 }

 fun canBe2(j: Int) {
-    (@label <!VAL_REASSIGNMENT!>j<!>) = <!UNUSED_VALUE!>34<!>
+    (label@ <!VAL_REASSIGNMENT!>j<!>) = <!UNUSED_VALUE!>34<!>
 }

 class A() {
@@ -75,18 +75,18 @@ class Test() {
    fun testIllegalValues() {
        <!VARIABLE_EXPECTED!>1<!> += 23
        (<!VARIABLE_EXPECTED!>1<!> : Int) += 43
-        (@l <!VARIABLE_EXPECTED!>1<!>) += 23
+        (l@ <!VARIABLE_EXPECTED!>1<!>) += 23

        <!VARIABLE_EXPECTED!>getInt()<!> += 343
-        (@f <!VARIABLE_EXPECTED!>getInt()<!>) += 343
+        (f@ <!VARIABLE_EXPECTED!>getInt()<!>) += 343
        (<!VARIABLE_EXPECTED!>getInt()<!> : Int) += 343

        <!VARIABLE_EXPECTED!>1<!>++
-        (@r <!VARIABLE_EXPECTED!>1<!>)++
+        (r@ <!VARIABLE_EXPECTED!>1<!>)++
        (<!VARIABLE_EXPECTED!>1<!> : Int)++

        <!VARIABLE_EXPECTED!>getInt()<!>++
-        (@m <!VARIABLE_EXPECTED!>getInt()<!>)++
+        (m@ <!VARIABLE_EXPECTED!>getInt()<!>)++
        (<!VARIABLE_EXPECTED!>getInt()<!> : Int)++

        this<!UNRESOLVED_REFERENCE!>++<!>
@@ -94,7 +94,7 @@ class Test() {
        var s : String = "r"
        s += "ss"
        s += this
-        s += (@a 2)
+        s += (a@ 2)
    }

    fun testVariables() {
@@ -102,13 +102,13 @@ class Test() {
        val b: Int = 34

        a += 34
-        (@l a) += 34
+        (l@ a) += 34
        (a : Int) += 34

        <!VAL_REASSIGNMENT!>b<!> += 34

        a++
-        (@l a)++
+        (l@ a)++
        (a : Int)++
        <!UNUSED_CHANGED_VALUE!>(a)++<!>
    }
@@ -116,7 +116,7 @@ class Test() {
    fun testVariables1() {
        val b: Int = 34

-        (@l <!VAL_REASSIGNMENT!>b<!>) += 34
+        (l@ <!VAL_REASSIGNMENT!>b<!>) += 34
        //repeat for b
        (b : Int) += 34
        (b) += 3
@@ -130,7 +130,7 @@ class Test() {
        ab.getArray()[54] = 23
        ab.getArray()[54]++

-        (@f a)[3] = 4
+        (f@ a)[3] = 4
        (a : Array<Int>)[4]++
        (ab.getArray() : Array<Int>)[54] += 43

@@ -21,6 +21,6 @@ fun main(args : Array<String>) {
    <!NO_COMPANION_OBJECT!>System<!> is Int
    <!INVISIBLE_MEMBER!>System<!>()
    (<!NO_COMPANION_OBJECT!>System<!>)
-    @foo <!NO_COMPANION_OBJECT!>System<!>
+    foo@ <!NO_COMPANION_OBJECT!>System<!>
    null in <!NO_COMPANION_OBJECT!>System<!>
 }
@@ -1,13 +1,13 @@
 fun test() {

-    @l for (i in if (true) 1..10 else <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue@l<!>) {}
+    l@ for (i in if (true) 1..10 else <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue@l<!>) {}
    for (i in if (true) 1..10 else <!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>) {}

    while (<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break<!>) {}
-    @l while (<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break@l<!>) {}
+    l@ while (<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>break@l<!>) {}

    do {} while (<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue<!>)
-    @l do {} while (<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue@l<!>)
+    l@ do {} while (<!BREAK_OR_CONTINUE_OUTSIDE_A_LOOP!>continue@l<!>)

    //KT-5704
    var i = 0
@@ -12,7 +12,7 @@ fun test2() {
    <!UNREACHABLE_CODE!>bar(<!>11, todo()/*comment1*/, <!UNREACHABLE_CODE!>""/*comment2*/)<!>
 }
 fun test3() {
-    <!UNREACHABLE_CODE!>bar(<!>11, @l(todo()/*comment*/), <!UNREACHABLE_CODE!>"")<!>
+    <!UNREACHABLE_CODE!>bar(<!>11, l@(todo()/*comment*/), <!UNREACHABLE_CODE!>"")<!>
 }

 fun todo() = throw Exception()
@@ -1,7 +1,7 @@
 //KT-5200 Mark unreachable code in lambdas

 fun test1(): String {
-    doCall @local {
+    doCall local@ {
        throw NullPointerException()
        <!UNREACHABLE_CODE!>"b3"<!> //unmarked
    }
@@ -10,7 +10,7 @@ fun test1(): String {
 }

 fun test2(nonLocal: String, b: Boolean): String {
-    doCall @local {
+    doCall local@ {
        if (b) {
            return@local "b1"
        } else {
@@ -5,7 +5,7 @@ class TestFunctionLiteral {
    val sum: (Int) -> Int = { x: Int ->
        sum(x - 1) + x
    }
-    val foo: () -> Unit = @l ({ foo() })
+    val foo: () -> Unit = l@ ({ foo() })
 }

 open class A(val a: A)
@@ -19,7 +19,7 @@ class TestObjectLiteral {
            val y = obj
        }
    }
-    val obj1: A = @l ( object: A(<!UNINITIALIZED_VARIABLE!>obj1<!>) {
+    val obj1: A = l@ ( object: A(<!UNINITIALIZED_VARIABLE!>obj1<!>) {
        init {
            val x = <!UNINITIALIZED_VARIABLE!>obj1<!>
        }
@@ -1,7 +1,7 @@
 fun call(f: () -> Unit) = f()

 fun f1() {
-    @outer while (true) {
+    outer@ while (true) {
        call {
            <!BREAK_OR_CONTINUE_JUMPS_ACROSS_FUNCTION_BOUNDARY!>break@outer<!>
        }
@@ -1,7 +1,7 @@
 fun whileLoop(x: Int?) {
-    @outer while (x != 0) {
+    outer@ while (x != 0) {
        while (x != 1) {
-            if (x == 2) continue @outer
+            if (x == 2) continue@outer
        }
        <!TYPE_MISMATCH!>x<!> : Int
    }
@@ -9,9 +9,9 @@ fun whileLoop(x: Int?) {
 }

 fun doWhileLoop(x: Int?) {
-    @outer while (x != 0) {
+    outer@ while (x != 0) {
        do {
-            if (x == 2) continue @outer
+            if (x == 2) continue@outer
        } while (x == null)
        <!TYPE_MISMATCH!>x<!> : Int
    }
@@ -19,10 +19,10 @@ fun doWhileLoop(x: Int?) {
 }

 fun whileLoopContinueInnerOuter(x: Int?) {
-    @outer while (x != 0) {
-        @inner while (x != 1) {
+    outer@ while (x != 0) {
+        inner@ while (x != 1) {
            while (x != 2) {
-                if (x == 3) continue @inner
+                if (x == 3) continue@inner
            }
            <!TYPE_MISMATCH!>x<!> : Int
        }
@@ -1,5 +1,5 @@
 class A3 {
-    val a: String by @l MyProperty()
+    val a: String by l@ MyProperty()

    class MyProperty<T> {}

@@ -1,3 +1,3 @@
 fun test() {
-    (@d <!DECLARATION_IN_ILLEGAL_CONTEXT!>val bar = 2<!>)
+    (d@ <!DECLARATION_IN_ILLEGAL_CONTEXT!>val bar = 2<!>)
 }
@@ -2,19 +2,19 @@ package m

 fun test(i: Int?) {
    if (i != null) {
-        foo(@l1 <!DEBUG_INFO_SMARTCAST!>i<!>)
+        foo(l1@ <!DEBUG_INFO_SMARTCAST!>i<!>)
        foo((<!DEBUG_INFO_SMARTCAST!>i<!>))
-        foo(@l2 (<!DEBUG_INFO_SMARTCAST!>i<!>))
-        foo((@l3 <!DEBUG_INFO_SMARTCAST!>i<!>))
+        foo(l2@ (<!DEBUG_INFO_SMARTCAST!>i<!>))
+        foo((l3@ <!DEBUG_INFO_SMARTCAST!>i<!>))
    }

-    val a: Int = @l4 <!TYPE_MISMATCH!>""<!>
+    val a: Int = l4@ <!TYPE_MISMATCH!>""<!>
    val b: Int = (<!TYPE_MISMATCH!>""<!>)
    val c: Int = <!TYPE_MISMATCH!>""<!>: Int
    val d: Int = <!TYPE_MISMATCH!><!TYPE_MISMATCH!>""<!>: Long<!>


-    foo(@l4 <!TYPE_MISMATCH!>""<!>)
+    foo(l4@ <!TYPE_MISMATCH!>""<!>)
    foo((<!TYPE_MISMATCH!>""<!>))
    foo(<!TYPE_MISMATCH!>""<!>: Int)
    foo(<!TYPE_MISMATCH!><!TYPE_MISMATCH!>""<!>: Long<!>)
@@ -13,7 +13,7 @@ fun test() {
 }

 fun foo() {
-    val bal = @bag fun () {
+    val bal = bag@ fun () {
        val bar = fun() {
            <!RETURN_NOT_ALLOWED!>return@bag<!>
        }
@@ -1,10 +1,10 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE

-val label_fun = @label fun () {
+val label_fun = label@ fun () {
    return@label
 }

-val parenthesized_label_fun = (@label fun () {
+val parenthesized_label_fun = (label@ fun () {
    return@label
 })

@@ -9,7 +9,7 @@ fun foo<T>(<!UNUSED_PARAMETER!>a<!>: A, f: () -> T): T = f()
 fun foo<T>(<!UNUSED_PARAMETER!>b<!>: B, f: () -> T): T = f()

 fun test(c: C) {
-    <!CANNOT_COMPLETE_RESOLVE!>foo<!>(c) @f {
+    <!CANNOT_COMPLETE_RESOLVE!>foo<!>(c) f@ {
        c<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
    }
 }
@@ -1,5 +1,5 @@
 val flag = true

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

 // type of a was checked by txt
-val a/*: () -> Any*/ = @l { // commonSupertype(Int, Unit) = Any
+val a/*: () -> Any*/ = l@ { // commonSupertype(Int, Unit) = Any
    if (flag) return@l 4
 }

-val b/*: () -> Int */ = @l {
+val b/*: () -> Int */ = l@ {
    if (flag) return@l 4
    5
 }

-val c/*: () -> Unit */ = @l {
+val c/*: () -> Unit */ = l@ {
    if (flag) <!UNUSED_EXPRESSION!>4<!>
 }
@@ -1,22 +1,22 @@
 val flag = true

-val a: () -> Int = @l {
+val a: () -> Int = l@ {
    <!TYPE_MISMATCH!>if (flag) return@l 4<!>
 }

-val b: () -> Unit = @l {
+val b: () -> Unit = l@ {
    if (flag) return@l <!CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
 }

-val c: () -> Any = @l {
+val c: () -> Any = l@ {
    if (flag) return@l 4
 }

-val d: () -> Int = @l {
+val d: () -> Int = l@ {
    if (flag) return@l 4
    5
 }

-val e: () -> Int = @l {
+val e: () -> Int = l@ {
    <!TYPE_MISMATCH!>if (flag) <!UNUSED_EXPRESSION!>4<!><!>
 }
@@ -1,6 +1,6 @@
 val flag = true

-val a /*: (Int) -> String */ = @l {
+val a /*: (Int) -> String */ = l@ {
    i: Int ->
    if (i == 0) return@l i.toString()

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

@@ -1,11 +1,11 @@
 fun test() {
-    val x = run(@f{return@f 1})
+    val x = run(f@{return@f 1})
    x: Int
 }


 fun test1() {
-    val x = run(@l{return@l 1})
+    val x = run(l@{return@l 1})
    x: Int
 }

@@ -1,5 +1,5 @@
 fun test() {
-    run1 @f{
+    run1 f@{
        (return@f 1)<!UNREACHABLE_CODE!>: Nothing<!>
    }
 }
@@ -1,5 +1,5 @@
 fun test() {
-    val x = run @f{
+    val x = run f@{
      fun local(a: Int): String {
        if (a > 0) return "2"
        return@local "3"
@@ -1,6 +1,6 @@
 fun test() {
-    val x = run @f{
-      run @ff {
+    val x = run f@{
+      run ff@ {
        return@ff "2"
      }
      return@f 1
@@ -1,5 +1,5 @@
 fun test(a: Int) {
-    run @f{
+    run f@{
      if (a > 0) return@f
      else return@f <!RETURN_TYPE_MISMATCH!>1<!>
    }
@@ -1,13 +1,13 @@
 class A
 val flag = true

-val a /*: () -> A?*/ = @l {
+val a /*: () -> A?*/ = l@ {
    if (flag) return@l null

    A()
 }

-val b /*: () -> A?*/ = @l {
+val b /*: () -> A?*/ = l@ {
    if (flag) return@l null

    return@l A()
@@ -1,6 +1,6 @@
 val flag = true

-val a = @b {
+val a = b@ {
    if (flag) return@b <!RETURN_TYPE_MISMATCH!>4<!>
    return@b
 }
@@ -1,5 +1,5 @@
 fun test(a: Int) {
-    val x = run @f{
+    val x = run f@{
      if (a > 0) return@f
      else return@f Unit
    }
@@ -1,7 +1,7 @@
 val flag = true

 // type of lambda was checked by txt
-val a = @b { // () -> Unit
+val a = b@ { // () -> Unit
    if (flag) return@b
    else <!UNUSED_EXPRESSION!>54<!>
 }
@@ -3,7 +3,7 @@ fun listOf<T>(vararg <!UNUSED_PARAMETER!>values<!>: T): List<T> = null!!

 val flag = true

-val a: () -> List<Int> = @l {
+val a: () -> List<Int> = l@ {
    if (flag) return@l listOf()
    listOf(5)
 }
@@ -1,16 +1,16 @@
 val flag = true

 // type of lambda was checked by txt
-val a = @l { // () -> Any
+val a = l@ { // () -> Any
    if (flag) return@l 4
    return@l Unit
 }

-val b = @l { // () -> Any
+val b = l@ { // () -> Any
    if (flag) return@l Unit
    5
 }

-val c = @l { // () -> Unit
+val c = l@ { // () -> Unit
    if (flag) return@l Unit
 }
@@ -1,5 +1,5 @@
 fun test(a: Int) {
-    run @f{ <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> ->
+    run f@{ <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> ->
      if (a > 0) return@f <!TYPE_MISMATCH!>""<!>
      return@f 1
    }
@@ -4,7 +4,7 @@ trait C: A


 fun test(a: C, b: B) {
-    val x = run @f{
+    val x = run f@{
      if (a != b) return@f a
      b
    }
@@ -1,6 +1,6 @@
 // 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
+val a /* :(Int?) -> Int? */ = l@ { it: Int? -> // but must be (Int?) -> Int
    if (it != null) return@l it
    5
 }
@@ -1,6 +1,6 @@
 // KT-6822 Smart cast doesn't work inside local returned expression in lambda

-val a : (Int?) -> Int = @l {
+val a : (Int?) -> Int = l@ {
    if (it != null) return@l <!DEBUG_INFO_SMARTCAST!>it<!>
    5
 }
@@ -1,8 +1,8 @@
-val a = @l {
+val a = l@ {
    return@l <!UNRESOLVED_REFERENCE!>r<!>
 }

-val b = @l {
+val b = l@ {
    if ("" == "OK") return@l

    return@l <!UNRESOLVED_REFERENCE, RETURN_TYPE_MISMATCH!>r<!>
@@ -4,7 +4,7 @@ trait Element

 fun test(handlers: Map<String, Element.()->Unit>) {

-    handlers.getOrElse("name", @l { return@l <!NULL_FOR_NONNULL_TYPE!>null<!> })
+    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")
@@ -6,7 +6,7 @@ import java.util.*
 fun expected<T>(t: T, <!UNUSED_PARAMETER!>f<!>: () -> T) : T = t

 fun test(arrayList: ArrayList<Int>, list: List<Int>) {
-    val <!UNUSED_VARIABLE!>t<!> = expected(arrayList, @l {return@l list.reverse() })
+    val <!UNUSED_VARIABLE!>t<!> = expected(arrayList, l@ {return@l list.reverse() })
 }

 fun <T> List<T>.reverse() : List<T> = this
@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE

 inline fun foo(bar1: (String.() -> Int) -> Int, bar2: (()->Int) -> Int) {
-    bar1 @label {
+    bar1 label@ {
        this@label.length()
    }

@@ -13,7 +13,7 @@ inline fun foo(bar1: (String.() -> Int) -> Int, bar2: (()->Int) -> Int) {
    //    this@bar1.length
    //}

-    bar2 @l {
+    bar2 l@ {
        11
    }

@@ -24,17 +24,17 @@ inline fun foo(bar1: (String.() -> Int) -> Int, bar2: (()->Int) -> Int) {
 }

 inline fun foo2(bar1: (String.() -> Int) -> Int) {
-    @l1 <!USAGE_IS_NOT_INLINABLE!>bar1<!>
+    l1@ <!USAGE_IS_NOT_INLINABLE!>bar1<!>

-    @l2 bar1 {
+    l2@ bar1 {
        11
    }

-    (@l3 bar1) {
+    (l3@ bar1) {
        11
    }

-    (@l5 (@l4 bar1)) {
+    (l5@ (l4@ bar1)) {
        11
    }
 }
@@ -1,5 +1,5 @@
 fun inlineCallExplicitError(): String {
-    inlineFun @lamba {
+    inlineFun lamba@ {
        if (true) {
            return@lamba 2
        }
@@ -10,7 +10,7 @@ fun inlineCallExplicitError(): String {
 }

 fun inlineCall(): String {
-    inlineFun @lamba {
+    inlineFun lamba@ {
        if (true) {
            return@lamba 2
        }
@@ -26,7 +26,7 @@ inline fun inlineFun(s: () -> Int) {


 fun noInlineCall(): String {
-    noInline @lambda {
+    noInline lambda@ {
        if (true) {
            return@lambda 2
        }
@@ -15,9 +15,9 @@ class Global(val value: String)

 fun test1(intKind: Kind, extKind: Kind): Global {

-    var externalResult = doCall @ext {
+    var externalResult = doCall ext@ {

-        val internalResult = doCall @int {
+        val internalResult = doCall int@ {
            if (intKind == Kind.LOCAL) {
                return@test1 Global("internal to global")
            } else if (intKind == EXT_RETURN) {
@@ -27,13 +27,13 @@ fun <R> fun3ValueArgument(p: () -> R) {


 fun <R> fun4(p: () -> R) {
-    inlineFun @lambda {
+    inlineFun lambda@ {
        return@lambda p();
    }
 }

 fun <R> fun4ValueArgument(p: () -> R) {
-    inlineFun (@lambda {
+    inlineFun (lambda@ {
        return@lambda p();
    })
 }
@@ -20,7 +20,7 @@ fun <R> fun3(p: () -> R) {
 }

 fun <R> fun4(p: () -> R) {
-    Z() inlineFun @lambda {
+    Z() inlineFun lambda@ {
        return@lambda p();
    }
 }
@@ -20,6 +20,6 @@ inline fun inlineFunWithInvoke2(s: (p: Int) -> Unit) {
 }

 inline fun propagation(s: (p: Int) -> Unit) {
-    inlineFunWithInvoke((@label (s: (p: Int) -> Unit)))
-    inlineFunWithInvoke((@label2 @label (s: (p: Int) -> Unit)))
+    inlineFunWithInvoke((label@ (s: (p: Int) -> Unit)))
+    inlineFunWithInvoke((label2@ label@ (s: (p: Int) -> Unit)))
 }
@@ -5,8 +5,8 @@ public inline fun <reified T> Array(n: Int, block: (Int) -> T): Array<T> = null!

 fun test() {
    val ints = Array<Int?>(2, { null })
-    ints.forEach @lit {
-        if (it == null) return @lit
+    ints.forEach lit@ {
+        if (it == null) return@lit
        use(<!DEBUG_INFO_SMARTCAST!>it<!> + 5)
    }
 }
@@ -1,5 +1,5 @@
 fun nonlocals(b : Boolean) {
-    @a<!UNUSED_FUNCTION_LITERAL!>{
+    a@<!UNUSED_FUNCTION_LITERAL!>{
        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
@@ -2,7 +2,7 @@
 //KT-3920 Labeling information is lost when passing through some expressions

 fun test() {
-    run @f{
+    run f@{
        val x = if (1 > 2) return@f 1 else 2
        2
    }
@@ -7,7 +7,7 @@ fun string(init: StringBuilder.() -> Unit): String{
    return answer.toString()
 }

-val str = string @l{
+val str = string l@{
    append("hello, ")

    val sub = string {
@@ -2,7 +2,7 @@
 //KT-4603 Labeling information is lost when passing through local classes or objects

 fun foo() {
-    val s: Int.() -> Unit = @l{
+    val s: Int.() -> Unit = l@{
        class Local(val y: Int = this@l) {
            fun bar() {
                val x: Int = this@l //unresolved
@@ -1,10 +1,10 @@
 //KT-591 Unresolved label in valid code

 fun test() {
-    val <!UNUSED_VARIABLE!>a<!>: (Int?).() -> Unit = @a{
+    val <!UNUSED_VARIABLE!>a<!>: (Int?).() -> Unit = a@{
        if (this != null) {
            val <!UNUSED_VARIABLE!>b<!>: String.() -> Unit = {
-                <!DEBUG_INFO_SMARTCAST!>this@a<!>.times(5) // @a Unresolved
+                <!DEBUG_INFO_SMARTCAST!>this@a<!>.times(5) // a@ Unresolved
            }
        }
    }
@@ -15,7 +15,7 @@ fun B.b() {
 }

 fun test() {
-    @b <!UNUSED_FUNCTION_LITERAL!>{ <!DEPRECATED_LAMBDA_SYNTAX!>B.()<!> ->
+    b@ <!UNUSED_FUNCTION_LITERAL!>{ <!DEPRECATED_LAMBDA_SYNTAX!>B.()<!> ->
        object : A {
            override fun foo() {
                this@b.bar()
@@ -8,8 +8,8 @@ fun main(args : Array<String>) {
    val <!UNUSED_VARIABLE!>h<!> : String = <!TYPE_MISMATCH!>v--<!>;
    val <!UNUSED_VARIABLE!>h1<!> : String = <!TYPE_MISMATCH!>--v<!>;
    val <!UNUSED_VARIABLE!>i<!> : String = <!TYPE_MISMATCH!>!true<!>;
-    val <!UNUSED_VARIABLE!>j<!> : String = @foo <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>;
-    val <!UNUSED_VARIABLE!>k<!> : String = @foo @bar <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>;
+    val <!UNUSED_VARIABLE!>j<!> : String = foo@ <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>;
+    val <!UNUSED_VARIABLE!>k<!> : String = foo@ bar@ <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>;
    val <!UNUSED_VARIABLE!>l<!> : String = <!TYPE_MISMATCH!>-1<!>;
    val <!UNUSED_VARIABLE!>m<!> : String = <!TYPE_MISMATCH!>+1<!>;
 }
@@ -4,7 +4,7 @@ package kt411

 fun f() {
    invoker(
-    @l{
+    l@{
        return@l 11 // expects Function, but should expect Int
    }
    )
@@ -13,13 +13,13 @@ fun invoker(<!UNUSED_PARAMETER!>gen<!> : () -> Int) : Int  = 0

 //more tests
 fun t1() {
-    val <!UNUSED_VARIABLE!>v<!> = @l{
+    val <!UNUSED_VARIABLE!>v<!> = l@{
        return@l 111
    }
 }

 fun t2() : String {
-    val <!UNUSED_VARIABLE!>g<!> : ()-> Int = @l{
+    val <!UNUSED_VARIABLE!>g<!> : ()-> Int = l@{
        if (true) {
            return@l 1
        }
@@ -30,7 +30,7 @@ fun t2() : String {

 fun t3() : String {
    invoker(
-    @l{
+    l@{
        if (true) {
            <!RETURN_NOT_ALLOWED!>return@t3 "1"<!>
        }
@@ -41,7 +41,7 @@ fun t3() : String {
    }
    )
    invoker(
-    @l{
+    l@{
        return@l 1
    }
    )
@@ -54,10 +54,10 @@ fun t3() : String {
 }

 fun t4() : Int {
-    val <!UNUSED_VARIABLE!>h<!> :  ()-> String = @l{
+    val <!UNUSED_VARIABLE!>h<!> :  ()-> String = l@{
        return@l "a"
    }
-    val <!UNUSED_VARIABLE!>g<!> :  ()-> String = @l{
+    val <!UNUSED_VARIABLE!>g<!> :  ()-> String = l@{
        return@l "a"
    }

@@ -3,5 +3,5 @@
 inline fun run1<T>(body : () -> T) : T = body()

 fun main1(<!UNUSED_PARAMETER!>args<!> : Array<String>) {
-    run1 @l{ 1 } // should not be an error
+    run1 l@{ 1 } // should not be an error
 }
@@ -1,7 +1,7 @@
 package c

 fun test() {
-    with (1) @l {
+    with (1) l@ {
        foo(1, <!NAMED_PARAMETER_NOT_FOUND!>zz<!> = { this@l } )
    }
 }
@@ -14,7 +14,7 @@ fun test(bar: Bar, a: A) {
    // no elements with error types
    fooInt((bar()))
    fooInt(if (true) bar() else bar())
-    fooInt(@label bar())
+    fooInt(label@ bar())
    fooInt(a.bar())
-    fooInt(((@label if (true) (a.bar()) else bar())))
+    fooInt(((label@ if (true) (a.bar()) else bar())))
 }
@@ -3,7 +3,7 @@ fun testEquals(x: Int) {
    if (<!SENSELESS_COMPARISON!>x == (null)<!>) {}
    if (<!SENSELESS_COMPARISON!>x == null: Nothing?<!>) {}
    if (<!SENSELESS_COMPARISON!>x == null: Nothing?<!>) {}
-    if (<!SENSELESS_COMPARISON!>x == @foo null<!>) {}
+    if (<!SENSELESS_COMPARISON!>x == foo@ null<!>) {}
 }

 fun testEqualsFlipped(x: Int) {
@@ -11,7 +11,7 @@ fun testEqualsFlipped(x: Int) {
    if (<!SENSELESS_COMPARISON!>(null) == x<!>) {}
    if (<!SENSELESS_COMPARISON!>null: Nothing? == x<!>) {}
    if (<!SENSELESS_COMPARISON!>null: Nothing? == x<!>) {}
-    if (<!SENSELESS_COMPARISON!>@foo null == x<!>) {}
+    if (<!SENSELESS_COMPARISON!>foo@ null == x<!>) {}
 }

 fun testNotEquals(x: Int) {
@@ -19,7 +19,7 @@ fun testNotEquals(x: Int) {
    if (<!SENSELESS_COMPARISON!>x != (null)<!>) {}
    if (<!SENSELESS_COMPARISON!>x != null: Nothing?<!>) {}
    if (<!SENSELESS_COMPARISON!>x != null: Nothing?<!>) {}
-    if (<!SENSELESS_COMPARISON!>x != @foo null<!>) {}
+    if (<!SENSELESS_COMPARISON!>x != foo@ null<!>) {}
 }

 fun testNotEqualsFlipped(x: Int) {
@@ -27,5 +27,5 @@ fun testNotEqualsFlipped(x: Int) {
    if (<!SENSELESS_COMPARISON!>(null) != x<!>) {}
    if (<!SENSELESS_COMPARISON!>null: Nothing? != x<!>) {}
    if (<!SENSELESS_COMPARISON!>null: Nothing? != x<!>) {}
-    if (<!SENSELESS_COMPARISON!>@foo null != x<!>) {}
+    if (<!SENSELESS_COMPARISON!>foo@ null != x<!>) {}
 }
@@ -1,6 +1,6 @@
 public fun foo(x: String?): Int {
    var y: Any
-    @loop while (true) {
+    loop@ while (true) {
        y = when (x) {
            null -> break@loop
            "abc" -> return 0
@@ -1,7 +1,7 @@
 fun x(): Boolean { return true }

 public fun foo(p: String?, r: String?): Int {
-    @outer do {
+    outer@ do {
        do {
            p!!.length()
            if (!x()) continue@outer
@@ -3,7 +3,7 @@ fun x(p: String): Boolean { return p == "abc" }
 public fun foo(p: String?, r: String?, q: String?): Int {
    while(true) {
        q!!.length()
-        @loop do {
+        loop@ do {
            while(true) {
                p!!.length()
                if (x(<!DEBUG_INFO_SMARTCAST!>p<!>)) break@loop
@@ -1,7 +1,7 @@
 fun x(): Boolean { return true }

 public fun foo(p: String?, r: String?, q: String?): Int {
-    @outer while(true) {
+    outer@ while(true) {
        q!!.length()
        do {
            if (x()) continue@outer
@@ -3,7 +3,7 @@ fun bar(): Boolean { return true }
 public fun foo(x: String?): Int {
    var y: Int?
    y = 0
-    @loop do {
+    loop@ do {
        <!DEBUG_INFO_SMARTCAST!>y<!> += when (x) {
            null -> break@loop
            "abc" -> return 0
@@ -1,5 +1,5 @@
 public fun foo(x: String?): Int {
-    @loop while (true) {
+    loop@ while (true) {
        when (x) {
            null -> break@loop
            "abc" -> return 0
@@ -1,5 +1,5 @@
 public fun foo(x: String?): Int {
-    @loop while (true) {
+    loop@ while (true) {
        when (x) {
            null -> return -1
            "abc" -> return 0
@@ -8,9 +8,9 @@ class A(val a:Int) {
        this@B : B
        this@A : A
      }
-      val <!UNUSED_VARIABLE!>b<!>: Double.() -> Unit = @a{ this@a : Double + this@xx : Char}
-      val <!UNUSED_VARIABLE!>c<!> = @a{ -> <!NO_THIS!>this@a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> this@xx : Char}
-      return (@a{this@a : Double + this@xx : Char})
+      val <!UNUSED_VARIABLE!>b<!>: Double.() -> Unit = a@{ this@a : Double + this@xx : Char}
+      val <!UNUSED_VARIABLE!>c<!> = a@{ -> <!NO_THIS!>this@a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> this@xx : Char}
+      return (a@{this@a : Double + this@xx : Char})
    }
  }
 }
@@ -23,11 +23,11 @@ fun test(d: dynamic) {

    d.foo({ x -> } : (Int) -> Unit)

-    d.foo(@label { x -> })
+    d.foo(label@ { x -> })

-    d.foo(@label ({ x, y -> }))
+    d.foo(label@ ({ x, y -> }))

-    d.foo((@label ({ <!DEPRECATED_LAMBDA_SYNTAX!>(x, y: Int)<!> -> })))
+    d.foo((label@ ({ <!DEPRECATED_LAMBDA_SYNTAX!>(x, y: Int)<!> -> })))

    d.foo(({ x -> }))