Migrate testdata to new lambda syntax

compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt

@@ -2,7 +2,7 @@
 
 fun box(): String {
     fun rec(n : Int) {
-        val x = { (m : Int) ->
+        val x = { m : Int ->
             if (n > 0) rec(n - 1)
         }
 

compiler/testData/codegen/box/closures/closureWithParameter.kt

@@ -1,5 +1,5 @@
 fun box() : String {
-    return apply( "OK", {(arg: String) -> arg } )
+    return apply( "OK", {arg: String -> arg } )
 }
 
 fun apply(arg : String, f :  (p:String) -> String) : String {

compiler/testData/codegen/box/closures/closureWithParameterAndBoxing.kt

@@ -1,5 +1,5 @@
 fun box() : String {
-    return if (apply( 5, {(arg: Int) -> arg + 13 } ) == 18) "OK" else "fail"
+    return if (apply( 5, {arg: Int -> arg + 13 } ) == 18) "OK" else "fail"
 }
 
 fun apply(arg : Int, f :  (p:Int) -> Int) : Int {

compiler/testData/codegen/box/closures/enclosingThis.kt

@@ -1,6 +1,6 @@
 class Point(val x:Int, val y:Int) {
     fun mul() :  (scalar:Int)->Point  {
-        return { (scalar:Int):Point -> Point(x * scalar, y * scalar) }
+        return { scalar:Int -> Point(x * scalar, y * scalar) }
     }
 }
 

compiler/testData/codegen/box/closures/extensionClosure.kt

@@ -1,7 +1,7 @@
 class Point(val x : Int, val y : Int)
 
 fun box() : String {
-    val answer = apply(Point(3, 5), { Point.(scalar : Int) : Point ->
+    val answer = apply(Point(3, 5), { scalar : Int ->
         Point(x * scalar, y * scalar)
     })
 

compiler/testData/codegen/box/closures/localReturn.kt

@@ -1,13 +1,13 @@
 fun box(): String {
     val a = 1
-    val explicitlyReturned = run1 @f{(): String ->
+    val explicitlyReturned = run1 @f{
         if (a > 0)
           return@f "OK"
         else "Fail 1"
     }
     if (explicitlyReturned != "OK") return explicitlyReturned
 
-    val implicitlyReturned = run1 @f{(): String ->
+    val implicitlyReturned = run1 @f{
         if (a < 0)
           return@f "Fail 2"
         else "OK"

compiler/testData/codegen/box/closures/localReturnWithAutolabel.kt

@@ -1,13 +1,13 @@
 fun box(): String {
     val a = 1
-    val explicitlyReturned = run1 {(): String ->
+    val explicitlyReturned = run1 {
         if (a > 0)
           return@run1 "OK"
         else "Fail 1"
     }
     if (explicitlyReturned != "OK") return explicitlyReturned
 
-    val implicitlyReturned = run1 {(): String ->
+    val implicitlyReturned = run1 {
         if (a < 0)
           return@run1 "Fail 2"
         else "OK"

compiler/testData/codegen/box/controlStructures/kt237.kt

@@ -5,7 +5,7 @@ fun main(args: Array<String>?) {
         //do not compile
     System.out?.println(fff<Unit>(Unit))  //do not compile
     System.out?.println(id<Unit>(y))  //do not compile
-    System.out?.println(fff<Unit>(id<Unit>(y)) == id<Unit>(foreach(arrayOfNulls<Int>(0) as Array<Int>,{(e : Int) : Unit -> })))  //do not compile
+    System.out?.println(fff<Unit>(id<Unit>(y)) == id<Unit>(foreach(arrayOfNulls<Int>(0) as Array<Int>,{ e : Int -> })))  //do not compile
 }
 class A<T>()
 
@@ -34,8 +34,8 @@ fun box() : String {
     a[0] = 0
     a[1] = 1
     a[2] = 2
-    foreach(a, { (el : Int) : Unit -> System.out?.println(el) })
+    foreach(a, { el : Int -> System.out?.println(el) })
-    almostFilter(a, { (el : Int) : Int -> el })
+    almostFilter(a, { el : Int -> el })
     main(null)
     return "OK"
 }

compiler/testData/codegen/box/extensionFunctions/kt1061.kt

@@ -1,7 +1,7 @@
 //KT-1061 Can't call function defined as a val
 
 object X {
-    val doit = { (i: Int) -> i }
+    val doit = { i: Int -> i }
 }
 
 fun box() : String = if (X.doit(3) == 3) "OK" else "fail"

compiler/testData/codegen/box/extensionFunctions/kt1290.kt

@@ -6,7 +6,7 @@ class Foo<T>(val filter: (T) -> Boolean) {
     }
 }
 
-fun foo() = Foo({ (i: Int) -> i < 5 }).bar(2)
+fun foo() = Foo({ i: Int -> i < 5 }).bar(2)
 
 fun box() : String {
     if (!foo()) return "fail"

compiler/testData/codegen/box/extensionFunctions/nested2.kt

@@ -1,6 +1,6 @@
 fun box() : String {
   val y = 12
-  val op = { (x:Int) -> (x + y).toString() }
+  val op = { x:Int -> (x + y).toString() }
 
   val op2 : Int.(Int) -> String = { op(this + it) }
 

compiler/testData/codegen/box/functions/functionLiteralExpression.kt

@@ -8,17 +8,17 @@ fun Int.foo2() : (i : Int) -> Int {
 
 fun fooT1<T>(t : T) = { t.toString() }
 
-fun fooT2<T>(t: T) = { (x:T) -> t.toString() + x.toString() }
+fun fooT2<T>(t: T) = { x:T -> t.toString() + x.toString() }
 
 fun box() : String {
   if( (10.foo1())() != "23910") return "foo1 fail"
   if( (10.foo2())(1) != 11 ) return "foo2 fail"
 
-  if(1.{Int.() -> this + 1}() != 2) return "test 3 failed";
+  if(1.(fun Int.() = this + 1)() != 2) return "test 3 failed";
   if(  {1}() != 1)  return "test 4 failed";
-  if(  {(x : Int) -> x}(1) != 1)  return "test 5 failed";
+  if(  {x : Int -> x}(1) != 1)  return "test 5 failed";
-  if(  1.{Int.(x : Int) -> x + this}(1) != 2) return "test 6 failed";
+  if(  1.(fun Int.(x: Int) = x + this)(1) != 2) return "test 6 failed";
-  if(  1.({Int.() -> this})() != 1)  return "test 7 failed";
+  if(  1.(fun Int.() = this)() != 1)  return "test 7 failed";
   if(  (fooT1<String>("mama"))() != "mama")  return "test 8 failed";
   if(  (fooT2<String>("mama"))("papa") != "mamapapa")  return "test 9 failed";
   return "OK"

compiler/testData/codegen/box/functions/functionNtoString.kt

@@ -7,22 +7,22 @@ fun check(expected: String, obj: Any?) {
 
 fun box(): String {
     check("kotlin.Function0<kotlin.Unit>")
-        { () : Unit -> }
+    { -> }
     check("kotlin.Function0<java.lang.Integer>")
-        { () : Int -> 42 }
+    {  -> 42 }
-    check("kotlin.Function1<java.lang.String, java.lang.Long>")
+    check("kotlin.Function1<java.lang.String, java.lang.Long>",
-        { (s: String) : Long -> 42.toLong() }
+          fun (s: String) = 42.toLong())
     check("kotlin.Function2<java.lang.Integer, java.lang.Integer, kotlin.Unit>")
-        { (x: Int, y: Int) : Unit -> }
+    { x: Int, y: Int -> }
 
-    check("kotlin.ExtensionFunction0<java.lang.Integer, kotlin.Unit>")
+    check("kotlin.ExtensionFunction0<java.lang.Integer, kotlin.Unit>",
-        { Int.() : Unit -> }
+          fun Int.() {})
-    check("kotlin.ExtensionFunction0<kotlin.Unit, java.lang.Integer>")
+    check("kotlin.ExtensionFunction0<kotlin.Unit, java.lang.Integer>",
-        { Unit.() : Int -> 42 }
+          fun Unit.(): Int = 42)
-    check("kotlin.ExtensionFunction1<java.lang.String, java.lang.String, java.lang.Long>")
+    check("kotlin.ExtensionFunction1<java.lang.String, java.lang.String, java.lang.Long>",
-        { String.(s: String) : Long -> 42.toLong() }
+          fun String.(s: String): Long = 42.toLong())
-    check("kotlin.ExtensionFunction2<java.lang.Integer, java.lang.Integer, java.lang.Integer, kotlin.Unit>")
+    check("kotlin.ExtensionFunction2<java.lang.Integer, java.lang.Integer, java.lang.Integer, kotlin.Unit>",
-        { Int.(x: Int, y: Int) : Unit -> }
+          fun Int.(x: Int, y: Int) {})
 
     return "OK"
 }

compiler/testData/codegen/box/functions/invoke/extensionInvokeOnExpr.kt

@@ -13,8 +13,8 @@ fun B.test(): String {
     if (foo()() != "##") return "fail3"
     if (foo()(42) != "#42") return "fail4"
     if ((foo())(42) != "#42") return "fail5"
-    if ({() -> A()}()() != "##") return "fail6"
+    if ({ -> A()}()() != "##") return "fail6"
-    if ({() -> A()}()(37) != "#37") return "fail7"
+    if ({ -> A()}()(37) != "#37") return "fail7"
     return "OK"
 }
 

compiler/testData/codegen/box/functions/invoke/invokeOnExprByConvention.kt

@@ -14,7 +14,7 @@ fun box(): String {
     if (foo()() != "##") return "fail3"
     if (foo()(42) != "#42") return "fail4"
     if ((foo())(42) != "#42") return "fail5"
-    if ({() -> A()}()() != "##") return "fail6"
+    if ({ -> A()}()() != "##") return "fail6"
-    if ({() -> A()}()(37) != "#37") return "fail7"
+    if ({ -> A()}()(37) != "#37") return "fail7"
     return "OK"
 }

compiler/testData/codegen/box/functions/kt395.kt

@@ -1,6 +1,6 @@
 fun Any.with(operation :  Any.() -> Any) = operation().toString()
 
-val f = { (a : Int) :Unit -> }
+val f = { a : Int -> }
 
 fun box () : String {
     return if(20.with {

compiler/testData/codegen/box/functions/kt785.kt

@@ -1,7 +1,7 @@
 class A() {
     var x : Int = 0
 
-    var z = { () ->
+    var z = {
         x++
     }
 }

compiler/testData/codegen/box/functions/localFunctions/kt2895.kt

@@ -2,7 +2,7 @@ fun outer() {
     fun inner(i: Int) {
         if (i > 0){
             {
-                (it: Int) -> inner(0) // <- invocation of literal itself is generated instead
+                it: Int -> inner(0) // <- invocation of literal itself is generated instead
             }.invoke(1)
         }
     }

compiler/testData/codegen/box/labels/propertyAccessorInnerExtensionFun.kt

@@ -1,6 +1,6 @@
 val Int.getter: Int
     get() {
-        val extFun = { Int.() ->
+        val extFun: Int.() -> Int = {
             this@getter
         }
         return this@getter.extFun()
@@ -10,7 +10,7 @@ val Int.getter: Int
 var Int.setter: Int
     get() = 1
     set(i: Int) {
-        val extFun = { Int.() ->
+        val extFun: Int.() -> Int = {
             this@setter
         }
         this@setter.extFun()

compiler/testData/codegen/box/reflection/functionLiteralGenericSignature.kt

@@ -10,13 +10,13 @@ fun assertGenericSuper(expected: String, function: Any?) {
 
 val unitFun = { }
 val intFun = { 42 }
-val stringParamFun = { (x: String) : Unit -> }
+val stringParamFun = { x: String -> }
-val listFun = { (l: List<String>) : List<String> -> l }
+val listFun = { l: List<String> -> l }
-val mutableListFun = { (l: MutableList<Double>) : MutableList<Int> -> null!! }
+val mutableListFun = fun (l: MutableList<Double>): MutableList<Int> = null!!
-val funWithIn = { (x: Comparable<String>) : Unit -> }
+val funWithIn = fun (x: Comparable<String>) {}
 
-val extensionFun = { Any.() : Unit -> }
+val extensionFun = fun Any.() {}
-val extensionWithArgFun = { Long.(x: Any) : Date -> Date() }
+val extensionWithArgFun = fun Long.(x: Any): Date = Date()
 
 fun box(): String {
     assertGenericSuper("kotlin.Function0<kotlin.Unit>", unitFun)

compiler/testData/codegen/box/regressions/kt3173.kt

@@ -1,4 +1,4 @@
 fun box(): String {
-    val sum = {Int.(other: Int) -> this + other }
+    val sum = fun Int.(other: Int) = this + other
     return if (1 sum 2 == 3) "OK" else "Fail"
 }

compiler/testData/codegen/box/regressions/kt3999.kt

@@ -19,7 +19,7 @@ fun test2() {
 }
 
 fun Int.foo(a: Int) = this * a
-val boo = {Int.(a: Int): Int -> this + a}
+val boo = fun Int.(a: Int): Int = this + a
 
 fun box(): String {
     test1()

compiler/testData/codegen/boxAgainstJava/sam/adapters/nonLiteralComparator.kt

@@ -4,7 +4,7 @@ fun box(): String {
     val list = ArrayList(Arrays.asList(3, 2, 4, 8, 1, 5))
     val expected = ArrayList(Arrays.asList(8, 5, 4, 3, 2, 1))
 
-    val f = { (a: Int, b: Int) -> b - a }
+    val f = { a: Int, b: Int -> b - a }
     JavaClass.sortIntList(list, f)
     return if (list == expected) "OK" else list.toString()
 }

compiler/testData/codegen/boxInline/capture/simpleCapturingInClass.1.kt

@@ -1,7 +1,7 @@
 fun testAll(): String {
     val inlineX = InlineAll()
 
-    return inlineX.inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inlineX.inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
                               "" + a1 + a2 + a3 + a4 + a5},
                           1, 12.0, 13.0, "14", 15)
 }
@@ -19,7 +19,7 @@ fun testAllWithCapturedVal(): String {
     val c8 = 27.toShort()
     val c9 = 28.toFloat()
 
-    return inlineX.inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inlineX.inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
                               "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
                           1, 12.0, 13.0, "14", 15)
 }
@@ -37,7 +37,7 @@ fun testAllWithCapturedVar(): String {
     var c8 = 27.toShort()
     val c9 = 28.toFloat()
 
-    return inlineX.inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inlineX.inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
                               "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
                           1, 12.0, 13.0, "14", 15)
 }
@@ -55,7 +55,7 @@ fun testAllWithCapturedValAndVar(): String {
     var c8 = 27.toShort()
     val c9 = 28.toFloat()
 
-    return inlineX.inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inlineX.inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
                               "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
                           1, 12.0, 13.0, "14", 15)
 }

compiler/testData/codegen/boxInline/capture/simpleCapturingInPackage.1.kt

@@ -1,7 +1,7 @@
 fun testAll(): String {
-    return inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
-                              "" + a1 + a2 + a3 + a4 + a5},
+                      "" + a1 + a2 + a3 + a4 + a5},
-                          1, 12.0, 13.0, "14", 15)
+                  1, 12.0, 13.0, "14", 15)
 }
 
 fun testAllWithCapturedVal(): String {
@@ -15,9 +15,9 @@ fun testAllWithCapturedVal(): String {
     val c8 = 27.toShort()
     val c9 = 28.toFloat()
 
-    return inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
-                              "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
+                      "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
-                          1, 12.0, 13.0, "14", 15)
+                  1, 12.0, 13.0, "14", 15)
 }
 
 fun testAllWithCapturedVar(): String {
@@ -31,9 +31,9 @@ fun testAllWithCapturedVar(): String {
     var c8 = 27.toShort()
     val c9 = 28.toFloat()
 
-    return inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
-                              "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
+                      "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
-                          1, 12.0, 13.0, "14", 15)
+                  1, 12.0, 13.0, "14", 15)
 }
 
 fun testAllWithCapturedValAndVar(): String {
@@ -47,9 +47,9 @@ fun testAllWithCapturedValAndVar(): String {
     var c8 = 27.toShort()
     val c9 = 28.toFloat()
 
-    return inline({(a1: Int, a2: Double, a3: Double, a4: String, a5: Long) ->
+    return inline({ a1: Int, a2: Double, a3: Double, a4: String, a5: Long ->
-                              "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
+                      "" + a1 + a2 + a3 + a4 + a5 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9},
-                          1, 12.0, 13.0, "14", 15)
+                  1, 12.0, 13.0, "14", 15)
 }
 
 

compiler/testData/codegen/boxInline/complex/closureChain.1.kt

@@ -1,6 +1,6 @@
 fun test1(): Int {
     val inlineX = Inline()
-    return inlineX.foo({(z: Int) -> "" + z}, 25, {String.() -> this.length()})
+    return inlineX.foo({ z: Int -> "" + z}, 25, fun String.(): Int = this.length())
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/defaultValues/defaultInExtension.1.kt

@@ -8,10 +8,10 @@ fun testExtensionInClass() : String {
     res = with(Z(1)) { "1".run() }
     if (res != "1null") return "failed in class 2: $res"
 
-    res = with(Z(2)) { "3".run("OK", {(a, b) -> a + b + value }, 1) }
+    res = with(Z(2)) { "3".run("OK", { a, b -> a + b + value }, 1) }
     if (res != "OK123") return "failed in class 3: $res"
 
-    res = with(Z(3)) { "4".run(lambda = {(a, b) -> a + b + value }) }
+    res = with(Z(3)) { "4".run(lambda = { a, b -> a + b + value }) }
     if (res != "034") return "failed in class 4: $res"
 
     return "OK"
@@ -25,10 +25,10 @@ fun box(): String {
     res = "1".run()
     if (res != "1null") return "failed 2: $res"
 
-    res = "3".run("OK", {(a, b) -> a + b}, 1)
+    res = "3".run("OK", { a, b -> a + b}, 1)
     if (res != "OK13") return "failed 3: $res"
 
-    res = "4".run(lambda = {(a, b) -> a + b})
+    res = "4".run(lambda = { a, b -> a + b})
     if (res != "04") return "failed 4: $res"
 
     return testExtensionInClass()

compiler/testData/codegen/boxInline/defaultValues/defaultMethodInClass.1.kt

@@ -5,9 +5,9 @@ fun box(): String {
 
     if (Z().run("OK") != "OK0") return "fail 2"
 
-    if (Z().run("OK", {(a, b) -> a + b }, 1) != "OK1") return "fail 3"
+    if (Z().run("OK", { a, b -> a + b }, 1) != "OK1") return "fail 3"
 
-    if (Z().run(lambda = {(a: String, b: Int) -> a + b }) != "0") return "fail 4"
+    if (Z().run(lambda = { a: String, b: Int -> a + b }) != "0") return "fail 4"
 
     return "OK"
 }

compiler/testData/codegen/boxInline/noInline/noInline.1.kt

@@ -1,5 +1,5 @@
 fun test1(): Int {
-    return calc( {(l : Int) -> 2*l},  {(l : Int) -> 4*l})
+    return calc( { l: Int -> 2*l},  { l: Int -> 4*l})
 }
 
 

compiler/testData/codegen/boxInline/noInline/withoutInline.1.kt

@@ -1,6 +1,6 @@
 fun test1(): Int {
     val inlineX = Inline()
-    var p = {(l : Int) -> l};
+    var p = { l : Int -> l};
     return inlineX.calc(p, 25)
 }
 

compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/bracket.1.kt

@@ -2,7 +2,6 @@ import test.*
 
 fun test1(b: Boolean): String {
     val localResult = doCall ((@local {
-        () : String ->
         if (b) {
             return@local "local"
         } else {

compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/labeled.1.kt

@@ -2,7 +2,6 @@ import test.*
 
 fun test1(b: Boolean): String {
     val localResult = doCall @local {
-        () : String ->
         if (b) {
             return@local "local"
         } else {

compiler/testData/codegen/boxInline/nonLocalReturns/explicitLocalReturn.1.kt

@@ -2,7 +2,6 @@ import test.*
 
 fun test1(b: Boolean): String {
     val localResult = doCall @local {
-        () : String ->
         if (b) {
             return@local "local"
         } else {

compiler/testData/codegen/boxInline/nonLocalReturns/nestedNonLocals.1.kt

@@ -16,10 +16,8 @@ class Global(val value: String)
 fun test1(intKind: Kind, extKind: Kind): Global {
 
     var externalResult = doCall @ext {
-        () : External ->
 
         val internalResult = doCall @int {
-            () : Internal ->
             if (intKind == Kind.GLOBAL) {
                 return@test1 Global("internal -> global")
             } else if (intKind == EXTERNAL) {

compiler/testData/codegen/boxInline/nonLocalReturns/noInlineLocalReturn.1.kt

@@ -2,7 +2,6 @@ import test.*
 
 fun test1(b: Boolean): String {
     val localResult = noInlineCall @local {
-        () : Int ->
         if (b) {
             return@local 1
         } else {

compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSite.1.kt

@@ -23,11 +23,9 @@ fun test1(intKind: Kind, extKind: Kind, holder: Holder): Global {
     holder.value = ""
     try {
         var externalResult = doCall @ext {
-            (): External ->
 
             try {
                 val internalResult = doCall @int {
-                    (): Internal ->
                     try {
                         if (intKind == Kind.GLOBAL) {
                             return@test1 Global("internal -> global")

compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/complex.1.kt

@@ -23,11 +23,9 @@ fun test1(intKind: Kind, extKind: Kind, holder: Holder): Global {
     holder.value = ""
     try {
         var externalResult = doCall (@ext {
-            (): External ->
 
             try {
                 val internalResult = doCall (@int {
-                    (): Internal ->
                     try {
                         if (intKind == Kind.GLOBAL) {
                             return@test1 Global("internal -> global")

compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTry.1.kt

@@ -18,7 +18,6 @@ fun test1(h: Holder): String {
 
 fun test2(h: Holder): String {
     val localResult = doCall (@lambda {
-        (): String ->
       h.value += "OK_LOCAL"
       return@lambda "OK_LOCAL"
     }, {

compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTryAndFinally.1.kt

@@ -22,7 +22,6 @@ fun test1(h: Holder): String {
 fun test2(h: Holder): String {
     val localResult = doCall (
             @lambda {
-                (): String ->
                 h.value += "OK_NONLOCAL"
                 return@lambda "OK_NONLOCAL"
             }, {
@@ -47,14 +46,12 @@ fun test3(h: Holder): String {
 }
 
 fun test4(h: Holder): String {
-    val localResult = doCall (
+    val localResult = doCall<String> (
             {
-                ():String ->
                 h.value += "OK_NONLOCAL"
                 return "OK_NONLOCAL"
             },
             @l2 {
-                ():String ->
                 h.value += ", OK_FINALLY"
                 return@l2 "OK_FINALLY"
             })

compiler/testData/codegen/boxInline/simple/extension.1.kt

@@ -1,11 +1,11 @@
 fun test1(): Int {
     val inlineX = Inline(9)
-    return inlineX.calcExt({(z: Int) -> z}, 25)
+    return inlineX.calcExt({ z: Int -> z}, 25)
 }
 
 fun test2(): Int {
     val inlineX = Inline(9)
-    return inlineX.calcExt2({Int.() -> this}, 25)
+    return inlineX.calcExt2(fun Int.(): Int = this, 25)
 }
 
 fun test3(): Int {
@@ -21,7 +21,7 @@ fun test4(): Double {
 fun test5(): Double {
     val inlineX = Inline(9)
     with(inlineX) {
-        11.0.calcDouble{(a: Int, b: Double) -> a + b}
+        11.0.calcDouble{ a: Int, b: Double -> a + b}
     }
     return inlineX.doWorkWithDouble(11.0)
 }

compiler/testData/codegen/boxInline/simple/extension.2.kt

@@ -19,11 +19,11 @@ class Inline(val res: Int) {
     }
 
     fun doWork(l : InlineX) : Int {
-        return l.calcInt({(a: Int, b: Int) -> a + b})
+        return l.calcInt({ a: Int, b: Int -> a + b})
     }
 
     fun doWorkWithDouble(s : Double) : Double {
-        return s.calcDouble({(a: Int, b: Double) -> a + b})
+        return s.calcDouble({ a: Int, b: Double -> a + b})
     }
 
 }

compiler/testData/codegen/boxInline/simple/params.1.kt

@@ -1,23 +1,23 @@
 
 fun test1(): Int {
     val inlineX = Inline()
-    return inlineX.foo1Int({(z: Int) -> z}, 25)
+    return inlineX.foo1Int({ z: Int -> z}, 25)
 }
 
 fun test2(): Double {
     val inlineX = Inline()
-    return inlineX.foo1Double(25.0, {(z: Double) -> z})
+    return inlineX.foo1Double(25.0, { z: Double -> z})
 }
 
 fun test3(): Double {
     val inlineX = Inline()
-    return inlineX.foo2Param(15.0, {(z1: Int, z2: Double) -> z1 + z2}, 10)
+    return inlineX.foo2Param(15.0, { z1: Int, z2: Double -> z1 + z2}, 10)
 }
 
 fun test3WithCaptured(): Double {
     val inlineX = Inline()
     var c = 11.0;
-    return inlineX.foo2Param(15.0, {(z1: Int, z2: Double) -> z1 + z2 + c}, 10)
+    return inlineX.foo2Param(15.0, { z1: Int, z2: Double -> z1 + z2 + c}, 10)
 }
 
 

compiler/testData/codegen/boxInline/simple/severalClosures.1.kt

@@ -1,17 +1,17 @@
 fun test1(): Double {
     val inlineX = Inline()
-    return inlineX.foo1({(z: Int) -> z}, 25, {(z: Double) -> z}, 11.5)
+    return inlineX.foo1({ z: Int -> z}, 25, { z: Double -> z}, 11.5)
 }
 
 fun test1WithCaptured(): Double {
     val inlineX = Inline()
     var d = 0.0;
-    return inlineX.foo1({(z: Int) -> d = 1.0; z}, 25, {(z: Double) -> z + d}, 11.5)
+    return inlineX.foo1({ z: Int -> d = 1.0; z}, 25, { z: Double -> z + d}, 11.5)
 }
 
 fun test2(): Double {
     val inlineX = Inline()
-    return inlineX.foo2({(z: Int, p: Int) -> z + p}, 25, {(x: Double, y: Int, z: Int) -> z + x + y}, 11.5, 2)
+    return inlineX.foo2({ z: Int, p: Int -> z + p}, 25, { x: Double, y: Int, z: Int -> z + x + y}, 11.5, 2)
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/simple/simpleDouble.1.kt

@@ -1,39 +1,39 @@
 fun test0Param(): Double {
     val inlineX = InlineDouble(10.0)
-    return inlineX.foo({() -> 1.0})
+    return inlineX.foo({ -> 1.0})
 }
 
 fun test1Param(): Double {
     val inlineX = InlineDouble(10.0)
-    return inlineX.foo11({(z: Double) -> z})
+    return inlineX.foo11({ z: Double -> z})
 }
 
 fun test1ParamCaptured(): Double {
     val s = 100.0
     val inlineX = InlineDouble(10.0)
-    return inlineX.foo11({(z: Double) -> s})
+    return inlineX.foo11({ z: Double -> s})
 }
 
 fun test1ParamMissed() : Double {
     val inlineX = InlineDouble(10.0)
-    return inlineX.foo11({(z: Double) -> 111.0})
+    return inlineX.foo11({ z: Double -> 111.0})
 }
 
 fun test1ParamFromCallContext() : Double {
     val inlineX = InlineDouble(1000.0)
-    return inlineX.fooRes({(z: Double) -> z})
+    return inlineX.fooRes({ z: Double -> z})
 }
 
 fun test2Params() : Double {
     val inlineX = InlineDouble(1000.0)
-    return inlineX.fooRes2({(y: Double, z: Double) -> 2.0 * y + 3.0 * z})
+    return inlineX.fooRes2({ y: Double, z: Double -> 2.0 * y + 3.0 * z})
 }
 
 fun test2ParamsWithCaptured() : Double {
     val inlineX = InlineDouble(1000.0)
     val s = 9.0
     var t = 1.0
-    return inlineX.fooRes2({(y: Double, z: Double) -> 2.0 * s + t})
+    return inlineX.fooRes2({ y: Double, z: Double -> 2.0 * s + t})
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/simple/simpleInt.1.kt

@@ -1,39 +1,39 @@
 fun test0Param(): Int {
     val inlineX = Inline(10)
-    return inlineX.foo({() -> 1})
+    return inlineX.foo({ -> 1})
 }
 
 fun test1Param(): Int {
     val inlineX = Inline(10)
-    return inlineX.foo11({(z: Int) -> z})
+    return inlineX.foo11({ z: Int -> z})
 }
 
 fun test1ParamCaptured(): Int {
     val s = 100
     val inlineX = Inline(10)
-    return inlineX.foo11({(z: Int) -> s})
+    return inlineX.foo11({ z: Int -> s})
 }
 
 fun test1ParamMissed() : Int {
     val inlineX = Inline(10)
-    return inlineX.foo11({(z: Int) -> 111})
+    return inlineX.foo11({ z: Int -> 111})
 }
 
 fun test1ParamFromCallContext() : Int {
     val inlineX = Inline(1000)
-    return inlineX.fooRes({(z: Int) -> z})
+    return inlineX.fooRes({ z: Int -> z})
 }
 
 fun test2Params() : Int {
     val inlineX = Inline(1000)
-    return inlineX.fooRes2({(y: Int, z: Int) -> 2 * y + 3 * z})
+    return inlineX.fooRes2({ y: Int, z: Int -> 2 * y + 3 * z})
 }
 
 fun test2ParamsWithCaptured() : Int {
     val inlineX = Inline(1000)
     val s = 9
     var t = 1
-    return inlineX.fooRes2({(y: Int, z: Int) -> 2 * s + t})
+    return inlineX.fooRes2({ y: Int, z: Int -> 2 * s + t})
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/simple/simpleObject.1.kt

@@ -1,39 +1,39 @@
 fun test0Param(): String {
     val inlineX = InlineString("10")
-    return inlineX.foo({() -> "1"})
+    return inlineX.foo({ -> "1"})
 }
 
 fun test1Param(): String {
     val inlineX = InlineString("10")
-    return inlineX.foo11({(z: String) -> z})
+    return inlineX.foo11({ z: String -> z})
 }
 
 fun test1ParamCaptured(): String {
     val s = "100"
     val inlineX = InlineString("10")
-    return inlineX.foo11({(z: String) -> s})
+    return inlineX.foo11({ z: String -> s})
 }
 
 fun test1ParamMissed() : String {
     val inlineX = InlineString("10")
-    return inlineX.foo11({(z: String) -> "111"})
+    return inlineX.foo11({ z: String -> "111"})
 }
 
 fun test1ParamFromCallContext() : String {
     val inlineX = InlineString("1000")
-    return inlineX.fooRes({(z: String) -> z})
+    return inlineX.fooRes({ z: String -> z})
 }
 
 fun test2Params() : String {
     val inlineX = InlineString("1000")
-    return inlineX.fooRes2({(y: String, z: String) -> y + "0" + z})
+    return inlineX.fooRes2({ y: String, z: String -> y + "0" + z})
 }
 
 fun test2ParamsWithCaptured() : String {
     val inlineX = InlineString("1000")
     val s = "9"
     var t = "1"
-    return inlineX.fooRes2({(y: String, z: String) -> s + t})
+    return inlineX.fooRes2({ y: String, z: String -> s + t})
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/simple/vararg.2.kt

@@ -1,5 +1,5 @@
 package test
 
 inline fun doSmth(vararg a: String) : String {
-    return a.foldRight("", {(a, b) -> a + b})
+    return a.foldRight("", { a, b -> a + b})
 }

compiler/testData/codegen/boxInline/special/inlineChain.1.kt

@@ -1,13 +1,13 @@
 fun test1(): String {
     val inlineX = My()
     var d = "";
-    inlineX.doWork({(z: String) -> d = z; z})
+    inlineX.doWork({ z: String -> d = z; z})
     return d
 }
 
 fun test2(): Int {
     val inlineX = My()
-    return inlineX.perform({(z: My) -> 11})
+    return inlineX.perform({ z: My -> 11})
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch2.1.kt

@@ -17,7 +17,7 @@ fun test11(): Int {
                     throw RuntimeException("2")
                 }
             },
-            {(ex, thizz) ->
+            { ex, thizz ->
                 if (ex.getMessage() == "2") {
                     thizz.value
                 } else {
@@ -48,7 +48,7 @@ fun test22(): Int {
                     111
                 }
             },
-            {(ex, thizz) ->
+            { ex, thizz ->
                 -11111
             })
 
@@ -80,7 +80,7 @@ fun test33(): Int {
                         throw RuntimeException("-2")
                     }
                 },
-                {(ex, thizz) ->
+                { ex, thizz ->
                     if (ex.getMessage() == "-2") {
                         throw RuntimeException("-3")
                     } else {

compiler/testData/codegen/boxInline/tryCatchFinally/tryCatchFinally.1.kt

@@ -48,7 +48,7 @@ fun test3(): Int {
                     result = it.value;
                     throw RuntimeException("-1")
                 },
-                { (e, z)->
+                { e, z ->
                     ++result
                     throw RuntimeException("-2")
                 },

compiler/testData/codegen/boxWithStdlib/arrays/kt4118.kt

@@ -1,10 +1,10 @@
 fun Array<String>.test1(): Array<String> {
-    val func = {(i:Int) -> this}
+    val func = { i:Int  -> this}
     return func(1)
 }
 
 fun Array<String>.test1Nested(): Array<String> {
-    val func = {(i:Int) -> { this }()}
+    val func = { i: Int -> { this }()}
     return func(1)
 }
 
@@ -71,7 +71,7 @@ fun Array<String>.test4Nested() : Array<String> {
 }
 
 fun Array<DoubleArray>.test1(): Array<DoubleArray> {
-    val func = {(i:Int) -> this}
+    val func = { i: Int -> this}
     return func(1)
 }
 

compiler/testData/codegen/boxWithStdlib/regressions/generic.kt

@@ -16,6 +16,6 @@ fun box(): String {
   list.add("Moscow")
   list.add("Munich")
 
-  val m: ArrayList<String> = list.findAll<String>({(name: String) -> name.startsWith("M")})
+  val m: ArrayList<String> = list.findAll<String>({ name: String -> name.startsWith("M")})
   return if (m.size() == 2) "OK" else "fail"
 }

compiler/testData/codegen/bytecodeText/directInvoke/inplaceClosure.kt

@@ -1,5 +1,5 @@
 fun test() {
-    1.{Int.() -> 2}()
+    1.(fun Int.() = 2)()
 }
 
 // 1 invoke \(I\)I

idea/testData/decompiler/decompiledText/FunctionTypes/FunctionTypes.kt

@@ -2,11 +2,11 @@ package test
 
 class FunctionTypes {
     public fun<IP, R, P1> Function1<IP, R>.compose(f: (P1) -> IP): (P1) -> R {
-        return {(p1: P1) -> this(f(p1)) }
+        return { p1: P1 -> this(f(p1)) }
     }
 
     public fun<IP, R, P1> ((IP) -> R).compose2(f: (P1) -> IP) : (P1) -> R {
-        return {(p1: P1) -> this(f(p1)) }
+        return { p1: P1 -> this(f(p1)) }
     }
 
     public fun <A> (A.(A) -> A).foo() {

idea/testData/intentions/convertParameterToReceiver/lambdaParameter.kt

@@ -1,6 +1,6 @@
 // IS_APPLICABLE: false
 
-val foo = {(<caret>s: String, n: Int) -> s.length() - n/2 > 1 }
+val foo = { <caret>s: String, n: Int -> s.length() - n/2 > 1 }
 
 fun test() {
     foo("1", 2)

idea/testData/intentions/operatorToFunction/functionCallWithMultipleArgumentsAndSingleLambda.kt

@@ -4,5 +4,5 @@ class Mocha() {
 }
 fun main() {
     val mocha = Mocha()
-    val testing = mocha<caret>(1, "fire"){ (x: Int) -> "hello world" }
+    val testing = mocha<caret>(1, "fire"){ x: Int -> "hello world" }
 }

idea/testData/intentions/operatorToFunction/functionCallWithMultipleArgumentsAndSingleLambda.kt.after

@@ -4,5 +4,5 @@ class Mocha() {
 }
 fun main() {
     val mocha = Mocha()
-    val testing = mocha.invoke(1, "fire"){ (x: Int) -> "hello world" }
+    val testing = mocha.invoke(1, "fire"){ x: Int -> "hello world" }
 }

idea/testData/intentions/operatorToFunction/functionCallWithSingleLambda.kt

@@ -3,5 +3,5 @@ class Mocha() {
 }
 fun main() {
     val mocha = Mocha()
-    val testing = mocha<caret>{ (x: Int) -> "hello world" }
+    val testing = mocha<caret>{ x: Int -> "hello world" }
 }

idea/testData/intentions/operatorToFunction/functionCallWithSingleLambda.kt.after

@@ -3,5 +3,5 @@ class Mocha() {
 }
 fun main() {
     val mocha = Mocha()
-    val testing = mocha.invoke{ (x: Int) -> "hello world" }
+    val testing = mocha.invoke{ x: Int -> "hello world" }
 }

idea/testData/intentions/operatorToFunction/notApplicableFunctionCallWithCallableReference.kt

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // IS_APPLICABLE: false
 fun foo() {
-    val bar = { (x: Int) -> x + 1 }
+    val bar = { x: Int -> x + 1 }
     val incremented = listOf(1, 2, 3).<caret>map(bar)
 }

idea/testData/intentions/removeExplicitTypeArguments/lambdaType.kt

@@ -1,6 +1,6 @@
 // IS_APPLICABLE: true
 fun foo() {
-    bar<caret><(Int) -> Int> { (it: Int) -> it }
+    bar<caret><(Int) -> Int> { it: Int -> it }
 }
 
 fun bar<T>(t: T): Int = 1

idea/testData/intentions/removeExplicitTypeArguments/lambdaType.kt.after

@@ -1,6 +1,6 @@
 // IS_APPLICABLE: true
 fun foo() {
-    bar { (it: Int) -> it }
+    bar { it: Int -> it }
 }
 
 fun bar<T>(t: T): Int = 1

idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt/notApplicable_notFunctionLiteralParameter.kt

@@ -1,6 +1,6 @@
 // IS_APPLICABLE: false
 
-val foo = { (x: Int) ->
+val foo = { x: Int ->
     class Inner() {
       fun temp(<caret>y: Int) : Int { return x + y }
     }

idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt/notApplicable_parameterHasExplicitType.kt

@@ -1,2 +1,2 @@
 // IS_APPLICABLE: false
-val incr = { (<caret>x: Int) -> x + 1}
+val incr = { <caret>x: Int -> x + 1}

idea/testData/intentions/specifyType/functionType.kt

@@ -1 +1 @@
-val x<caret> = { (a: Int) -> ""}
+val x<caret> = { a: Int -> ""}

idea/testData/intentions/specifyType/functionType.kt.after

@@ -1 +1 @@
-val x: (Int) -> String = { (a: Int) -> ""}
+val x: (Int) -> String = { a: Int -> ""}

idea/testData/quickfix/autoImports/afterSAMConstructorFromLambda.kt

@@ -6,6 +6,6 @@ import java.util.Comparator
 fun foo() {
     Collections.sort(
             ArrayList<Int>(),
-            <caret>Comparator {(x: Int, y: Int) -> x - y }
+            <caret>Comparator { x: Int, y: Int -> x - y }
     )
 }

idea/testData/quickfix/autoImports/beforeSAMConstructorFromLambda.kt

@@ -5,6 +5,6 @@ import java.util.ArrayList
 fun foo() {
     Collections.sort(
             ArrayList<Int>(),
-            <caret>Comparator {(x: Int, y: Int) -> x - y }
+            <caret>Comparator { x: Int, y: Int -> x - y }
     )
 }

idea/testData/quickfix/createFromUsage/createClass/callExpression/afterCallWithLambdaArg.kt

@@ -1,7 +1,7 @@
 // "Create class 'Foo'" "true"
 
 fun test() {
-    val a = Foo(2, "2") { (p: Int) -> p + 1 }
+    val a = Foo(2, "2") { p: Int -> p + 1 }
 }
 
 class Foo(i: Int, s: String, function: Function1<Int, Int>) {

idea/testData/quickfix/createFromUsage/createClass/callExpression/afterCallWithLambdaArgOnly.kt

@@ -1,7 +1,7 @@
 // "Create class 'Foo'" "true"
 
 fun test() {
-    val a = Foo { (p: Int) -> p + 1 }
+    val a = Foo { p: Int -> p + 1 }
 }
 
 class Foo(function: Function1<Int, Int>) {

idea/testData/quickfix/createFromUsage/createClass/callExpression/beforeCallWithLambdaArg.kt

@@ -1,5 +1,5 @@
 // "Create class 'Foo'" "true"
 
 fun test() {
-    val a = <caret>Foo(2, "2") { (p: Int) -> p + 1 }
+    val a = <caret>Foo(2, "2") { p: Int -> p + 1 }
 }

idea/testData/quickfix/createFromUsage/createClass/callExpression/beforeCallWithLambdaArgOnly.kt

@@ -1,5 +1,5 @@
 // "Create class 'Foo'" "true"
 
 fun test() {
-    val a = <caret>Foo { (p: Int) -> p + 1 }
+    val a = <caret>Foo { p: Int -> p + 1 }
 }

idea/testData/quickfix/createFromUsage/createFunction/call/afterCallWithLambdaArg.kt

@@ -8,5 +8,5 @@ class A<T>(val n: T) {
 }
 
 fun test() {
-    val a: A<Int> = A(1).foo(2, "2") { (p: Int) -> p + 1 }
+    val a: A<Int> = A(1).foo(2, "2") { p: Int -> p + 1 }
 }

idea/testData/quickfix/createFromUsage/createFunction/call/afterCallWithLambdaArgOnly.kt

@@ -8,5 +8,5 @@ class A<T>(val n: T) {
 }
 
 fun test() {
-    val a: A<Int> = A(1).foo { (p: Int) -> p + 1 }
+    val a: A<Int> = A(1).foo { p: Int -> p + 1 }
 }

idea/testData/quickfix/createFromUsage/createFunction/call/beforeCallWithLambdaArg.kt

@@ -5,5 +5,5 @@ class A<T>(val n: T) {
 }
 
 fun test() {
-    val a: A<Int> = A(1).<caret>foo(2, "2") { (p: Int) -> p + 1 }
+    val a: A<Int> = A(1).<caret>foo(2, "2") { p: Int -> p + 1 }
 }

idea/testData/quickfix/createFromUsage/createFunction/call/beforeCallWithLambdaArgOnly.kt

@@ -5,5 +5,5 @@ class A<T>(val n: T) {
 }
 
 fun test() {
-    val a: A<Int> = A(1).<caret>foo { (p: Int) -> p + 1 }
+    val a: A<Int> = A(1).<caret>foo { p: Int -> p + 1 }
 }

idea/testData/quickfix/createFromUsage/createVariable/localVariable/afterInLambdaWithParams.kt

@@ -2,7 +2,7 @@
 // ACTION: Create parameter 'foo'
 
 fun test(n: Int) {
-    val f: (Int, Int) -> Int = { (a, b) ->
+    val f: (Int, Int) -> Int = { a, b ->
         val foo = 0
         foo
     }

idea/testData/quickfix/createFromUsage/createVariable/localVariable/afterInMultiLineLambdaWithParams.kt

@@ -2,7 +2,7 @@
 // ACTION: Create parameter 'foo'
 
 fun test(n: Int) {
-    val f: (Int, Int) -> Int = { (a, b) ->
+    val f: (Int, Int) -> Int = { a, b ->
         val foo = 0
         foo
     }

idea/testData/quickfix/createFromUsage/createVariable/localVariable/beforeInLambdaWithParams.kt

@@ -2,5 +2,5 @@
 // ACTION: Create parameter 'foo'
 
 fun test(n: Int) {
-    val f: (Int, Int) -> Int = { (a, b) -> <caret>foo }
+    val f: (Int, Int) -> Int = { a, b -> <caret>foo }
 }

idea/testData/quickfix/createFromUsage/createVariable/localVariable/beforeInMultiLineLambdaWithParams.kt

@@ -2,7 +2,7 @@
 // ACTION: Create parameter 'foo'
 
 fun test(n: Int) {
-    val f: (Int, Int) -> Int = { (a, b) ->
+    val f: (Int, Int) -> Int = { a, b ->
         <caret>foo
     }
 }

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInLambdaWithParams.kt

@@ -2,5 +2,5 @@
 // ACTION: Create local variable 'foo'
 
 fun test(n: Int, foo: Int) {
-    val f: (Int, Int) -> Int = { (a, b) -> foo }
+    val f: (Int, Int) -> Int = { a, b -> foo }
 }

idea/testData/quickfix/createFromUsage/createVariable/parameter/afterInLambdaWithTypedParams.kt

@@ -2,5 +2,5 @@
 // ACTION: Create local variable 'foo'
 
 fun test(n: Int, foo: Any) {
-    val f = { (a: Int, b: Int) -> foo }
+    val f = { a: Int, b: Int -> foo }
 }

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInLambdaWithParams.kt

@@ -2,5 +2,5 @@
 // ACTION: Create local variable 'foo'
 
 fun test(n: Int) {
-    val f: (Int, Int) -> Int = { (a, b) -> <caret>foo }
+    val f: (Int, Int) -> Int = { a, b -> <caret>foo }
 }

idea/testData/quickfix/createFromUsage/createVariable/parameter/beforeInLambdaWithTypedParams.kt

@@ -2,5 +2,5 @@
 // ACTION: Create local variable 'foo'
 
 fun test(n: Int) {
-    val f = { (a: Int, b: Int) -> <caret>foo }
+    val f = { a: Int, b: Int -> <caret>foo }
 }

idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeFunctionParameterType1.kt

@@ -1,5 +1,5 @@
 // "Change parameter 'x' type of function 'bar.foo' to '(String) -> Int'" "true"
 package bar
 fun foo(w: Int = 0, x: (String) -> Int, y: Int = 0, z: (Int) -> Int = {42}) {
-    foo(1, {(a: String) -> 42}<caret>, 1)
+    foo(1, { a: String -> 42}<caret>, 1)
 }

idea/testData/quickfix/typeMismatch/parameterTypeMismatch/afterChangeParameterTypeLongNameRuntime.kt

@@ -4,5 +4,5 @@ package bar
 import kotlin.modules.Module
 
 fun foo(w: Int = 0, x: (Module) -> Int, y: Int = 0, z: (Int) -> Int = {42}) {
-    foo(1, {(a: kotlin.modules.Module) -> 42}<caret>, 1)
+    foo(1, { a: kotlin.modules.Module -> 42}<caret>, 1)
 }

idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeFunctionParameterType1.kt

@@ -1,5 +1,5 @@
 // "Change parameter 'x' type of function 'bar.foo' to '(String) -> Int'" "true"
 package bar
 fun foo(w: Int = 0, x: Int, y: Int = 0, z: (Int) -> Int = {42}) {
-    foo(1, {(a: String) -> 42}<caret>, 1)
+    foo(1, { a: String -> 42}<caret>, 1)
 }

idea/testData/quickfix/typeMismatch/parameterTypeMismatch/beforeChangeParameterTypeLongNameRuntime.kt

@@ -1,5 +1,5 @@
 // "Change parameter 'x' type of function 'bar.foo' to '(Module) -> Int'" "true"
 package bar
 fun foo(w: Int = 0, x: Int, y: Int = 0, z: (Int) -> Int = {42}) {
-    foo(1, {(a: kotlin.modules.Module) -> 42}<caret>, 1)
+    foo(1, { a: kotlin.modules.Module -> 42}<caret>, 1)
 }

idea/testData/shortenRefs/constructor/SAMConstructorFromLambda.kt

@@ -4,6 +4,6 @@ import java.util.ArrayList
 fun foo() {
     Collections.sort(
             ArrayList<Int>(),
-            <selection>java.util.Comparator</selection> {(x: Int, y: Int) -> x - y }
+            <selection>java.util.Comparator</selection> { x: Int, y: Int -> x - y }
     )
 }

idea/testData/shortenRefs/constructor/SAMConstructorFromLambda.kt.after

@@ -5,6 +5,6 @@ import java.util.Comparator
 fun foo() {
     Collections.sort(
             ArrayList<Int>(),
-            Comparator {(x: Int, y: Int) -> x - y }
+            Comparator { x: Int, y: Int -> x - y }
     )
 }

idea/testData/unifier/equivalence/declarations/localCallables/lambdas/multipleParamsRuntime.kt

@@ -1,23 +1,23 @@
 fun foo(f: (Int) -> Unit) {
-    <selection>{ (n: Int, s: String) ->
+    <selection>{ n: Int, s: String ->
         val a = n + 1
         println(s)
         f(a)
     }</selection>
 
-    { (s: String, n: Int) ->
+    { s: String, n: Int ->
         val a = n + 1
         println(s)
         f(a)
     }
 
-    { (m: Int, r: String) ->
+    { m: Int, r: String ->
         val b = m + 1
         println(r)
         f(b)
     }
 
-    val g: (Int, String) -> Unit = { (a, b) ->
+    val g: (Int, String) -> Unit = { a, b ->
         val m = a + 1
         println(b)
         f(m)

idea/testData/unifier/equivalence/declarations/localCallables/lambdas/multipleParamsRuntime.kt.match

@@ -1,16 +1,16 @@
-{ (n: Int, s: String) ->
+{ n: Int, s: String ->
         val a = n + 1
         println(s)
         f(a)
     }
 
-{ (m: Int, r: String) ->
+{ m: Int, r: String ->
         val b = m + 1
         println(r)
         f(b)
     }
 
-{ (a, b) ->
+{ a, b ->
         val m = a + 1
         println(b)
         f(m)

idea/testData/unifier/equivalence/declarations/localCallables/lambdas/singleParam.kt

@@ -1,5 +1,5 @@
 fun foo(f: (Int) -> Unit) {
-    <selection>{ (n: Int) ->
+    <selection>{ n: Int ->
         val a = n + 1
         f(a)
     }</selection>
@@ -9,7 +9,7 @@ fun foo(f: (Int) -> Unit) {
         f(a)
     }
 
-    { (m: Int) ->
+    { m: Int ->
         val b = m + 1
         f(b)
     }

idea/testData/unifier/equivalence/declarations/localCallables/lambdas/singleParam.kt.match

@@ -1,4 +1,4 @@
-{ (n: Int) ->
+{ n: Int ->
         val a = n + 1
         f(a)
     }
@@ -8,7 +8,7 @@
         f(a)
     }
 
-{ (m: Int) ->
+{ m: Int ->
         val b = m + 1
         f(b)
     }

idea/testData/unifier/equivalence/types/function2.kt

@@ -1,11 +1,11 @@
-val a: Function2<Any, Int, String> = { (a, b) -> "" }
+val a: Function2<Any, Int, String> = { a, b -> "" }
-val b: kotlin.Function2<kotlin.Any, kotlin.Int, kotlin.String> = { (a, b) -> "" }
+val b: kotlin.Function2<kotlin.Any, kotlin.Int, kotlin.String> = { a, b -> "" }
-val c: <selection>(Any, Int) -> String</selection> = { (a, b) -> "" }
+val c: <selection>(Any, Int) -> String</selection> = { a, b -> "" }
-val d: (a: Any, n: Int) -> kotlin.String = { (a, b) -> "" }
+val d: (a: Any, n: Int) -> kotlin.String = { a, b -> "" }
 val e: (String) -> Int = { 0 }
 val f: () -> Int = { 0 }
 val g: Any.(Int) -> String = { "" }
 val h: Int.(Any) -> String = { "" }
-val i: ExtensionFunction2<Any, Any, Int, String> = { (a, b) -> "" }
+val i: ExtensionFunction2<Any, Any, Int, String> = { a, b -> "" }
-val j: (t: Any, u: Int) -> kotlin.String = {(a, b) ->  "" }
+val j: (t: Any, u: Int) -> kotlin.String = { a, b ->  "" }
 val k: ExtensionFunction1<Any, Int, String> = { "" }

js/js.translator/testData/dataClass/cases/hashcode.kt

@@ -32,7 +32,7 @@ fun assertAllEqual<T>(c: Iterable<out T>) {
 
 val hashCoder: (o: Any) -> Int = { o -> o.hashCode() }
 
-val <T> wrapInH = { (t: T) -> Holder(t) }
+val <T> wrapInH = { t: T -> Holder(t) }
 
 fun box(): String {
 

js/js.translator/testData/expression/compareTo/cases/customCompareToMethod.kt

@@ -7,7 +7,7 @@ class A(val value: Int) : Comparable<A> {
 class B(val value: Int)
 
 fun testExtensionFunctionAsCompareTo() {
-    val compareTo: B.( B ) -> Int = { (other) -> other.value compareTo this.value }
+    val compareTo: B.( B ) -> Int = { other -> other.value compareTo this.value }
 
     val x: B = B(100)
     val y: B = B(200)

js/js.translator/testData/expression/function/cases/adderClosure.kt

@@ -2,7 +2,7 @@ package foo
 
 fun box(): Boolean {
     var sum = 0
-    val adder = {(a: Int) -> sum += a }
+    val adder = { a: Int -> sum += a }
     adder(3)
     adder(2)
     return sum == 5

js/js.translator/testData/expression/function/cases/closureWithParameter.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    return apply("OK", {(arg: String) -> arg })
+    return apply("OK", { arg: String -> arg })
 }
 
 fun apply(arg: String, f: (p: String) -> String): String {

js/js.translator/testData/expression/function/cases/closureWithParameterAndBoxing.kt

@@ -1,7 +1,7 @@
 package foo
 
 fun box(): String {
-    return if (apply(5, {(arg: Int) -> arg + 13 }) == 18) "OK" else "fail"
+    return if (apply(5, { arg: Int -> arg + 13 }) == 18) "OK" else "fail"
 }
 
 fun apply(arg: Int, f: (p: Int) -> Int): Int {