Replace deprecated lambda syntax in testData

It's done with similar constructions where possible trying to preserve
intended behavior.
Some usages are removed because they test exactly the feature that
we are going to drop soon.

compiler/testData/diagnostics/tests/annotations/onFunctionParameter.kt

@@ -5,5 +5,3 @@ fun test(@ann <!UNUSED_PARAMETER!>p<!>: Int) {
 }
 
 val bar = fun(@ann <!UNUSED_PARAMETER!>g<!>: Int) {}
-
-val bas = { <!DEPRECATED_LAMBDA_SYNTAX!>(@ann t: Int)<!> -> }

compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt

@@ -1,7 +1,6 @@
 package
 
 public val bar: (kotlin.Int) -> kotlin.Unit
-public val bas: (kotlin.Int) -> kotlin.Unit
 public fun test(/*0*/ @ann() p: kotlin.Int): kotlin.Unit
 
 @kotlin.annotation.annotation() public final class ann : kotlin.Annotation {

compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt

@@ -34,7 +34,7 @@ fun test4() {
 // should be an error on receiver, shouldn't be thrown away
 
 fun test5() {
-    <!TYPE_MISMATCH!>1<!>.{ <!DEPRECATED_LAMBDA_SYNTAX!>String.(): String<!> -> this}()
+    <!TYPE_MISMATCH!>1<!>.(fun String.()=1)()
 }
 
 fun <R: Any> R?.sure() : R = this!!

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

@@ -1,16 +1,16 @@
-val receiver = { <!DEPRECATED_LAMBDA_SYNTAX!>Int.()<!> -> }
-val receiverWithParameter = { <!DEPRECATED_LAMBDA_SYNTAX!>Int.(<!CANNOT_INFER_PARAMETER_TYPE!>a<!>)<!> -> }
+val receiver = { Int.(<!SYNTAX!><!>) <!SYNTAX!>-><!> }
+val receiverWithParameter = { Int.<!ILLEGAL_SELECTOR!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>)<!> <!SYNTAX!>-><!> }
 
-val receiverAndReturnType = { <!DEPRECATED_LAMBDA_SYNTAX!>Int.(): Int<!> ->  5 }
-val receiverAndReturnTypeWithParameter = { <!DEPRECATED_LAMBDA_SYNTAX!>Int.(a: Int): Int<!> ->  5 }
+val receiverAndReturnType = { Int.(<!SYNTAX!><!>): Int <!SYNTAX!>->  5<!> }
+val receiverAndReturnTypeWithParameter = { Int.<!ILLEGAL_SELECTOR!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>: <!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>)<!>: Int <!SYNTAX!>->  5<!> }
 
-val returnType = { <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> -> 5 }
-val returnTypeWithParameter = { <!DEPRECATED_LAMBDA_SYNTAX!>(b: Int): Int<!> -> 5 }
+val returnType = { (<!SYNTAX!><!>): Int <!SYNTAX!>-> 5<!> }
+val returnTypeWithParameter = { (<!UNRESOLVED_REFERENCE!>b<!>: Int)<!DEPRECATED_STATIC_ASSERT!>: Int<!> <!SYNTAX!>-> 5<!> }
 
-val receiverWithFunctionType = { <!DEPRECATED_LAMBDA_SYNTAX!>((Int) -> Int).()<!> -> }
+val receiverWithFunctionType = { ((Int)<!SYNTAX!><!> <!SYNTAX!>-> Int).() -><!> }
 
-val parenthesizedParameters = { <!DEPRECATED_LAMBDA_SYNTAX!>(a: Int)<!> -> }
-val parenthesizedParameters2 = { <!DEPRECATED_LAMBDA_SYNTAX!>(<!CANNOT_INFER_PARAMETER_TYPE!>b<!>)<!> -> }
+val parenthesizedParameters = { (<!UNRESOLVED_REFERENCE!>a<!>: Int) <!SYNTAX!>-><!> }
+val parenthesizedParameters2 = { (<!UNRESOLVED_REFERENCE!>b<!>) <!SYNTAX!>-><!> }
 
 val none = { -> }
 

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

@@ -7,12 +7,12 @@ public val newSyntax3: (???, kotlin.Int) -> kotlin.Unit
 public val newSyntax4: (kotlin.Int, ???) -> kotlin.Unit
 public val none: () -> kotlin.Unit
 public val parameterWithFunctionType: () -> ((kotlin.Int) -> kotlin.Int) -> [ERROR : No type element]
-public val parenthesizedParameters: (kotlin.Int) -> kotlin.Unit
-public val parenthesizedParameters2: (???) -> kotlin.Unit
-public val receiver: kotlin.Int.() -> kotlin.Unit
-public val receiverAndReturnType: kotlin.Int.() -> kotlin.Int
-public val receiverAndReturnTypeWithParameter: kotlin.Int.(kotlin.Int) -> kotlin.Int
-public val receiverWithFunctionType: ((kotlin.Int) -> kotlin.Int).() -> kotlin.Unit
-public val receiverWithParameter: kotlin.Int.(???) -> kotlin.Unit
+public val parenthesizedParameters: () -> kotlin.Int
+public val parenthesizedParameters2: () -> ???
+public val receiver: () -> ???
+public val receiverAndReturnType: () -> kotlin.Int
+public val receiverAndReturnTypeWithParameter: () -> kotlin.Int
+public val receiverWithFunctionType: () -> kotlin.Int.Companion
+public val receiverWithParameter: () -> ???
 public val returnType: () -> kotlin.Int
-public val returnTypeWithParameter: (kotlin.Int) -> kotlin.Int
+public val returnTypeWithParameter: () -> kotlin.Int

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

@@ -1,3 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
 package a
 
 interface Super
@@ -8,12 +9,12 @@ fun foo(f: (Trait) -> Trait) = f
 
 fun test(s: Sub) {
     foo {
-        <!DEPRECATED_LAMBDA_SYNTAX!>(t: Super): Sub<!> -> s
+        t: Super -> s
     }
     foo {
-        <!DEPRECATED_LAMBDA_SYNTAX!>(t: Trait): Trait<!> -> s
-    }
-    foo {
-        <!DEPRECATED_LAMBDA_SYNTAX!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>t: Sub<!>): <!EXPECTED_RETURN_TYPE_MISMATCH!>Super<!><!> -> s
+        t: Trait -> s
     }
+
+    foo(<!TYPE_MISMATCH!>fun(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>t: Sub<!>) = s<!>)
+    foo(<!TYPE_MISMATCH!>fun(t): Super = s<!>)
 }

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

@@ -9,26 +9,23 @@ fun test1() {
         ""
     }
     foo0 {
-        <!DEPRECATED_LAMBDA_SYNTAX, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(s: String)<!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>s: String<!>-> ""
     }
     foo0 {
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
     }
-    foo0 {
-        <!DEPRECATED_LAMBDA_SYNTAX!>(): <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!><!> -> 42
-    }
 
     foo1 {
         ""
     }
     foo1 {
-        <!DEPRECATED_LAMBDA_SYNTAX!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!>)<!> -> ""
+        <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
     }
     foo1 {
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
     }
     foo1 {
-        <!DEPRECATED_LAMBDA_SYNTAX!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!>: <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!><!> -> 42
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
     }
 
 
@@ -36,12 +33,12 @@ fun test1() {
         ""
     }
     foo2 {
-        <!DEPRECATED_LAMBDA_SYNTAX, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!>)<!> -> ""
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> ""
     }
     foo2 {
         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
     }
     foo2 {
-        <!DEPRECATED_LAMBDA_SYNTAX!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!>: <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!><!> -> 42
+         <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
     }
 }

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

@@ -1,11 +1,11 @@
 fun test(a: Int) {
-    run f@{ <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> ->
+    run<Int>f@{
       if (a > 0) return@f <!TYPE_MISMATCH!>""<!>
       return@f 1
     }
 
-    run { <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> -> <!TYPE_MISMATCH!>""<!> }
-    run { <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> -> 1 }
+    run<Int>{ <!TYPE_MISMATCH!>""<!> }
+    run<Int>{ 1 }
 }
 
 fun run<T>(f: () -> T): T { return f() }

compiler/testData/diagnostics/tests/inference/regressions/kt2484.kt

@@ -8,15 +8,11 @@ fun <T> Array<T>.forEach(operation: (T) -> Unit) : Unit { for (element in this)
 fun bar(operation: (String) -> Unit) = operation("")
 
 fun main(args: Array<String>) {
-    args.forEach { <!DEPRECATED_LAMBDA_SYNTAX!>(a : String) : Unit<!> -> a.length() } // Type mismatch: (String) -> Unit required, (String) -> Int found
-    args.forEach { <!DEPRECATED_LAMBDA_SYNTAX!>(a) : Unit<!> -> a.length() } // Type mismatch: (String) -> Unit required, (String) -> Int found
-    args.forEach { <!DEPRECATED_LAMBDA_SYNTAX!>(a : String)<!> -> a.length() } // Type mismatch: (String) -> Unit required, (String) -> Int found
+    args.forEach { a : String -> a.length() } // Type mismatch: (String) -> Unit required, (String) -> Int found
     args.forEach { a -> a.length() } // Type mismatch: (String) -> Unit required, (String) -> Int found
     args.forEach { it.length() }     // This works!
 
-    bar { <!DEPRECATED_LAMBDA_SYNTAX!>(a: String) : Unit<!> -> a.length() }
-    bar { <!DEPRECATED_LAMBDA_SYNTAX!>(a) : Unit<!> -> a.length() }
-    bar { <!DEPRECATED_LAMBDA_SYNTAX!>(a: String)<!> -> a.length() }
+    bar { a: String -> a.length() }
     bar { a -> a.length() }
     bar { it.length() }
 }

compiler/testData/diagnostics/tests/infos/SmartCasts.kt

@@ -176,9 +176,15 @@ fun returnFunctionLiteralBlock(a: Any?): Function0<Int> {
     if (a is Int) return { <!DEBUG_INFO_SMARTCAST!>a<!> }
     else return { 1 }
 }
-fun returnFunctionLiteral(a: Any?): Function0<Int> =
-    if (a is Int) { <!DEPRECATED_LAMBDA_SYNTAX!>(): Int<!> -> <!DEBUG_INFO_SMARTCAST!>a<!> }
-    else { <!DEPRECATED_LAMBDA_SYNTAX!>()<!> -> 1 }
+fun returnFunctionLiteral(a: Any?): Function0<Int> {
+    if (a is Int) return { -> <!DEBUG_INFO_SMARTCAST!>a<!> }
+    else return { -> 1 }
+}
+
+fun returnFunctionLiteralDoesntWork(a: Any?): Function0<Int> =
+        if (a is Int) <!TYPE_MISMATCH!>{ -> a }<!>
+        else { -> 1 }
+
 
 fun mergeSmartCasts(a: Any?) {
   if (a is String || a is Int) {

compiler/testData/diagnostics/tests/infos/SmartCasts.txt

@@ -17,6 +17,7 @@ public fun illegalWhenBody(/*0*/ a: kotlin.Any): kotlin.Int
 public fun mergeSmartCasts(/*0*/ a: kotlin.Any?): kotlin.Unit
 public fun returnFunctionLiteral(/*0*/ a: kotlin.Any?): () -> kotlin.Int
 public fun returnFunctionLiteralBlock(/*0*/ a: kotlin.Any?): () -> kotlin.Int
+public fun returnFunctionLiteralDoesntWork(/*0*/ a: kotlin.Any?): () -> kotlin.Int
 public fun toInt(/*0*/ i: kotlin.Int?): kotlin.Int
 public fun vars(/*0*/ a: kotlin.Any?): kotlin.Unit
 

compiler/testData/diagnostics/tests/inline/propagation.kt

@@ -6,8 +6,8 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
 }
 
 inline fun inlineFunWithInvokeClosure(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
-    subInline({p: Int -> s(p)}, {<!DEPRECATED_LAMBDA_SYNTAX!>Int.(p:Int)<!> -> this.ext(p)})
-    subNoInline({p: Int -> s(p)}, {<!DEPRECATED_LAMBDA_SYNTAX!>Int.(p:Int)<!> -> this.ext(p)})
+    subInline({p: Int -> s(p)}, { p -> this.ext(p)})
+    subNoInline({p: Int -> s(p)}, { p -> this.ext(p)})
 }
 
 //No inline
@@ -17,8 +17,8 @@ inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit, noinline e
 }
 
 inline fun inlineFunWithInvokeClosureNoinline(noinline s: (p: Int) -> Unit, noinline ext: Int.(p: Int) -> Unit) {
-    subInline({p: Int -> s(p)}, {<!DEPRECATED_LAMBDA_SYNTAX!>Int.(p:Int)<!> -> this.ext(p)})
-    subNoInline({p: Int -> s(p)}, {<!DEPRECATED_LAMBDA_SYNTAX!>Int.(p:Int)<!> -> this.ext(p)})
+    subInline({p: Int -> s(p)}, { p -> this.ext(p)})
+    subNoInline({p: Int -> s(p)}, { p -> this.ext(p)})
 }
 
 //ext function
@@ -28,8 +28,8 @@ inline fun Function1<Int, Unit>.inlineExt(ext: Int.(p: Int) -> Unit) {
 }
 
 inline fun Function1<Int, Unit>.inlineExtWithClosure(ext: Int.(p: Int) -> Unit) {
-    subInline({p: Int -> this(p)}, {<!DEPRECATED_LAMBDA_SYNTAX!>Int.(p:Int)<!> -> this.ext(p)})
-    subNoInline({p: Int -> this(p)}, {<!DEPRECATED_LAMBDA_SYNTAX!>Int.(p:Int)<!> -> this.ext(p)})
+    subInline({p: Int -> this(p)}, { p -> this.ext(p)})
+    subNoInline({p: Int -> this(p)}, { p -> this.ext(p)})
 }
 
 inline fun subInline(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {}

compiler/testData/diagnostics/tests/labels/labelReferencesInsideObjectExpressions.kt

@@ -14,12 +14,14 @@ fun B.b() {
     }
 }
 
+
 fun test() {
-    b@ <!UNUSED_FUNCTION_LITERAL!>{ <!DEPRECATED_LAMBDA_SYNTAX!>B.()<!> ->
+    fun <T> without(f: T.() -> Unit): Unit = (null!!).f<!UNREACHABLE_CODE!>()<!>
+    without<B>() b@ {
         object : A {
             override fun foo() {
                 this@b.bar()
             }
         }
-    }<!>
+    }
 }

compiler/testData/diagnostics/tests/labels/labelsMustBeNamed.kt

@@ -1,5 +1,5 @@
 fun foo(a: Any?): Int {
-    <!SYNTAX!>@<!>{ () : Unit ->
+    <!SYNTAX!>@<!>{ ->
         return<!SYNTAX!>@<!>
     }
 

compiler/testData/diagnostics/tests/regressions/kt306.kt

@@ -1,16 +1,17 @@
 // KT-306 Ambiguity when different this's have same-looking functions
 
 fun test() {
-    <!UNUSED_FUNCTION_LITERAL!>{<!DEPRECATED_LAMBDA_SYNTAX!>Foo.()<!> ->
-        bar();
-        {<!DEPRECATED_LAMBDA_SYNTAX!>Barr.()<!> ->
+    (fun Foo.() {
+        bar()
+        (fun Barr.() {
             this.bar()
             bar()
-        }
-    }<!>
-    <!UNUSED_FUNCTION_LITERAL!>{<!DEPRECATED_LAMBDA_SYNTAX!>Barr.()<!> ->
+        })
+    })
+    (fun Barr.() {
+        this.bar()
         bar()
-    }<!>
+    })
 }
 
 class Foo {

compiler/testData/diagnostics/tests/regressions/kt352.kt

@@ -2,18 +2,19 @@
 
 package kt352
 
-val f : (Any) -> Unit = { <!DEPRECATED_LAMBDA_SYNTAX!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!> : Unit<!> -> }  //type mismatch
+val f : (Any) -> Unit = {  <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> }  //type mismatch
 
 fun foo() {
-    val <!UNUSED_VARIABLE!>f<!> : (Any) -> Unit = { <!DEPRECATED_LAMBDA_SYNTAX!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!> : Unit<!> -> }  //!!! no error
+    val <!UNUSED_VARIABLE!>f<!> : (Any) -> Unit = { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> }  //!!! no error
 }
 
 class A() {
-    val f : (Any) -> Unit = { <!DEPRECATED_LAMBDA_SYNTAX!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!> : Unit<!> -> }  //type mismatch
+    val f : (Any) -> Unit = { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> }  //type mismatch
 }
 
 //more tests
-val g : () -> Unit = { <!DEPRECATED_LAMBDA_SYNTAX!>(): <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!><!> -> 42 }
+val g : () -> Unit = { <!UNUSED_EXPRESSION!>42<!> }
+val gFunction : () -> Unit = <!TYPE_MISMATCH!>fun(): Int = 1<!>
 
 val h : () -> Unit = { doSmth() }
 

compiler/testData/diagnostics/tests/regressions/kt352.txt

@@ -3,6 +3,7 @@ package
 package kt352 {
     public val f: (kotlin.Any) -> kotlin.Unit
     public val g: () -> kotlin.Unit
+    public val gFunction: () -> kotlin.Unit
     public val h: () -> kotlin.Unit
     public val testIt: (kotlin.Any) -> kotlin.Unit
     public fun doSmth(): kotlin.Int

compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiterals.kt

@@ -16,11 +16,11 @@ object A {
 fun foo(i: Int, f: (Int)->Int) = f(i)
 
 fun test() {
-    foo(1) { <!DEPRECATED_LAMBDA_SYNTAX!>(x1: Int):Int<!> ->
-        foo(2) { <!DEPRECATED_LAMBDA_SYNTAX!>(x2: Int): Int<!> ->
-            foo(3) { <!DEPRECATED_LAMBDA_SYNTAX!>(x3: Int): Int<!> ->
-                foo(4) { <!DEPRECATED_LAMBDA_SYNTAX!>(x4: Int): Int<!> ->
-                    foo(5) { <!DEPRECATED_LAMBDA_SYNTAX!>(x5: Int): Int<!> ->
+    foo(1) { x1: Int ->
+        foo(2) { x2: Int ->
+            foo(3) { x3: Int ->
+                foo(4) { x4: Int ->
+                    foo(5) { x5: Int ->
                         x1 + x2 + x3 + x4 + x5 + A.iii
                     }
                 }

compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralsOverload.kt

@@ -17,11 +17,11 @@ fun foo(a: Any, f: (Any)->Int) = f(a)
 fun foo(i: Int, f: (Int)->Int) = f(i)
 
 fun test() {
-    foo(1) { <!DEPRECATED_LAMBDA_SYNTAX!>(x1: Int):Int<!> ->
-        foo(2) { <!DEPRECATED_LAMBDA_SYNTAX!>(x2: Int): Int<!> ->
-            foo(3) { <!DEPRECATED_LAMBDA_SYNTAX!>(x3: Int): Int<!> ->
-                foo(4) { <!DEPRECATED_LAMBDA_SYNTAX!>(x4: Int): Int<!> ->
-                    foo(5) { <!DEPRECATED_LAMBDA_SYNTAX!>(x5: Int): Int<!> ->
+    foo(1) { x1: Int ->
+        foo(2) { x2: Int ->
+            foo(3) { x3: Int ->
+                foo(4) { x4: Int ->
+                    foo(5) { x5: Int ->
                         x1 + x2 + x3 + x4 + x5 + A.iii
                     }
                 }