Fixed test data for new lambda syntax

compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.kt

@@ -3,7 +3,7 @@ tailRecursive fun <T, A> Iterator<T>.foldl(acc : A, foldFunction : (e : T, acc :
         else foldl(foldFunction(next(), acc), foldFunction)
 
 fun box() : String {
-    val sum = (1..1000000).iterator().foldl(0) { (e : Int, acc : Long) ->
+    val sum = (1..1000000).iterator().foldl(0) { e : Int, acc : Long ->
         acc + e
     }
 

compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt

@@ -52,16 +52,15 @@ fun main(args : Array<String>) {
 fun f() :  Int.() -> Unit = {}
 
 fun main1() {
-    1.{Int.() -> 1}();
+    1.(fun Int.() = 1)();
     {1}();
-    {(x : Int) -> x}(1)
+    (fun (x : Int) = x)(1)
-    1.{Int.(x : Int) -> x}(1);
+    1.(fun Int.(x : Int) = x)(1);
     @l{1}()
-    1.({Int.() -> 1})()
+    1.((fun Int.() = 1))()
     1.(f())()
     1.if(true){f()}else{f()}()
-    1.if(true){Int.() -> <!UNUSED_EXPRESSION!>1<!>}else{f()}()
+    1.if(true)(fun Int.() {})else{f()}()
-    1.if(true){Int.() -> 1}else{Int.() -> 1}()
 
     1.<!FUNCTION_EXPECTED!>"sdf"<!>()
 
@@ -71,12 +70,12 @@ fun main1() {
 }
 
 fun test() {
-    {(x : Int) -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
+    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
-    <!MISSING_RECEIVER!>{Int.() -> 1}<!>()
+    <!MISSING_RECEIVER!>(fun Int.() = 1)<!>()
-    <!TYPE_MISMATCH!>"sd"<!>.{Int.() -> 1}()
+    <!TYPE_MISMATCH!>"sd"<!>.(fun Int.() = 1)()
     val i : Int? = null
-    i<!UNSAFE_CALL!>.<!>{Int.() -> 1}();
+    i<!UNSAFE_CALL!>.<!>(fun Int.() = 1)();
     {}<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>()
-    1<!UNNECESSARY_SAFE_CALL!>?.<!>{Int.() -> 1}()
+    1<!UNNECESSARY_SAFE_CALL!>?.<!>(fun Int.() = 1)()
     1.<!NO_RECEIVER_ALLOWED!>{}<!>()
 }

compiler/testData/diagnostics/tests/FunctionParameterWithoutType.kt

@@ -7,5 +7,5 @@ class A(a<!SYNTAX!><!>)
 
 val bar = fun test(<!CANNOT_INFER_PARAMETER_TYPE!>a<!>){}
 
-val la = { (<!CANNOT_INFER_PARAMETER_TYPE!>a<!>) -> }
+val la = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!> -> }
-val las = { (a: Int) -> }
+val las = { a: Int -> }

compiler/testData/diagnostics/tests/FunctionReturnTypes.kt

@@ -174,12 +174,12 @@ fun testFunctionLiterals() {
         <!EXPECTED_TYPE_MISMATCH!>val <!UNUSED_VARIABLE!>x<!> = 2<!>
     }
 
-    val <!UNUSED_VARIABLE!>endsWithAssignment<!> = { () : Int ->
+    val <!UNUSED_VARIABLE!>endsWithAssignment<!>: () -> Int = {
         var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>x<!> = 1
         <!EXPECTED_TYPE_MISMATCH!>x = <!UNUSED_VALUE!>333<!><!>
     }
 
-    val <!UNUSED_VARIABLE!>endsWithReAssignment<!> = { () : Int ->
+    val <!UNUSED_VARIABLE!>endsWithReAssignment<!>: () -> Int = {
         var x = 1
         <!ASSIGNMENT_TYPE_MISMATCH!>x += 333<!>
     }
@@ -196,11 +196,11 @@ fun testFunctionLiterals() {
         <!LOCAL_OBJECT_NOT_ALLOWED, EXPECTED_TYPE_MISMATCH!>object A<!> {}
     }
 
-    val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!> = { () : Unit ->
+    val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!>: () -> Unit = {
         val <!UNUSED_VARIABLE!>x<!> = 1
     }
 
-    val <!UNUSED_VARIABLE!>expectedUnitReturnType2<!> = { () : Unit ->
+    val <!UNUSED_VARIABLE!>expectedUnitReturnType2<!>: () -> Unit = {
         fun meow() : Unit {}
         <!LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}
     }

compiler/testData/diagnostics/tests/UnusedVariables.kt

@@ -103,11 +103,11 @@ fun testInnerFunctions() {
 
 fun testFunctionLiterals() {
     var x = 1
-    var <!UNUSED_VARIABLE!>fl<!> = { (): Int ->
+    var <!UNUSED_VARIABLE!>fl<!> = {
         x
     }
     var y = 2
-    var <!UNUSED_VARIABLE!>fl1<!> = { (): Unit ->
+    var <!UNUSED_VARIABLE!>fl1<!> = {
         doSmth(y)
     }
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.kt

@@ -2,7 +2,6 @@
 
 fun test1(): String {
     doCall @local {
-        () : String ->
         throw NullPointerException()
         <!UNREACHABLE_CODE!>"b3"<!> //unmarked
     }
@@ -12,7 +11,6 @@ fun test1(): String {
 
 fun test2(nonLocal: String, b: Boolean): String {
     doCall @local {
-        () : String ->
         if (b) {
             return@local "b1"
         } else {

compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1977.kt

@@ -30,7 +30,7 @@ fun test2(s : String) : Int? {
         22
     } finally {
             <!UNUSED_FUNCTION_LITERAL!>{
-            (x : Int) -> x
+            x : Int -> x
             }<!>
     }
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt

@@ -2,7 +2,7 @@
 package o
 
 class TestFunctionLiteral {
-    val sum: (Int) -> Int = { (x: Int) ->
+    val sum: (Int) -> Int = { x: Int ->
         sum(x - 1) + x
     }
     val foo: () -> Unit = @l ({ foo() })

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

@@ -1,18 +1,17 @@
 fun f() {
-    foo {(): Int ->
+    foo {
         return@foo 1
     }
-    foo({(): Int ->
+    foo({
         return@foo 1
     }
     )
-    foo(a = {(): Int ->
+    foo(a = {
         return@foo 1
     })
 
-    foo {(): Int ->
+    foo {
         foo {
-            (): Int ->
             return<!LABEL_NAME_CLASH!>@foo<!> 1
         }
         return@foo 1

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

@@ -1,7 +1,6 @@
 fun f() {
-    foo {(): Int ->
+    foo {
         bar {
-            (): Int ->
             <!RETURN_NOT_ALLOWED!>return@foo 1<!>
         }
         return@foo 1

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

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

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

@@ -1,5 +1,5 @@
 fun test() {
-    run1 @f{(): Int ->
+    run1 @f{
         (return@f 1)<!UNREACHABLE_CODE!>: Nothing<!>
     }
 }

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

@@ -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
 }

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

@@ -1,12 +1,12 @@
 fun unusedLiteral(){
-    <!UNUSED_FUNCTION_LITERAL!>{() ->
+    <!UNUSED_FUNCTION_LITERAL!>{ ->
         val <!UNUSED_VARIABLE!>i<!> = 1
     }<!>
 }
 
 
 fun unusedLiteralInDoWhile(){
-    do<!UNUSED_FUNCTION_LITERAL!>{() ->
+    do<!UNUSED_FUNCTION_LITERAL!>{ ->
             val <!UNUSED_VARIABLE!>i<!> = 1
     }<!> while(false)
 }

compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.kt

@@ -6,7 +6,7 @@ import java.util.Comparator
 
 fun foo() {
 
-    val <!UNUSED_VARIABLE!>c<!>: Comparator<Date?> = comparator {(date1, date2) ->
+    val <!UNUSED_VARIABLE!>c<!>: Comparator<Date?> = comparator { date1, date2 ->
         if (date1 != null && date2 != null) {
             date1.compareTo(date2) * -11
         } else {

compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt

@@ -5,7 +5,7 @@ fun <T> emptyList(): List<T> = throw Exception()
 fun foo<T>(f: T.() -> Unit, l: List<T>): T = throw Exception("$f$l")
 
 fun test() {
-    val q = foo({ Int.() -> }, emptyList()) //type inference no information for parameter error
+    val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
     q: Int
 
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())

compiler/testData/diagnostics/tests/inference/kt3184.kt

@@ -8,7 +8,7 @@ private fun <T> test(value: T, extf: String.(value: T)->Unit) {
 }
 
 fun main(args: Array<String>) {
-    test(1, {(value) -> println(value)})
+    test(1, {value -> println(value)})
 }
 
 fun tests() {

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

@@ -11,7 +11,7 @@ public fun<TItem, TResult> select(<!UNUSED_PARAMETER!>yielder<!>: ()->Iterable<T
 
 fun a() {
     val x = 0..200
-    val z = x where { (i: Int) -> i % 2 == 0 }
+    val z = x where { i: Int -> i % 2 == 0 }
     val yielder = select(x where { it%2==0 }, { it.toString() })
 
     z : () -> Iterable<Int>

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

@@ -3,7 +3,7 @@
 package d
 
 fun test(numbers: Iterable<Int>) {
-    val s = numbers.map{it.toString()}.fold(""){(it, it2) -> it + it2}
+    val s = numbers.map{it.toString()}.fold(""){it, it2 -> it + it2}
     <!TYPE_MISMATCH!>s<!>: Int
 }
 

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

@@ -14,7 +14,7 @@ abstract class Buggy {
         get() = <!TYPE_MISMATCH!>coll.find{ it > 3 }<!> // does not work here
 
     val yetAnotherThree : Int
-        get() = <!TYPE_MISMATCH!>coll.find({ (v:Int) -> v > 3 })<!> // neither here
+        get() = <!TYPE_MISMATCH!>coll.find({ v:Int -> v > 3 })<!> // neither here
 
     val extendedGetter : Int
         get() {

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

@@ -8,7 +8,7 @@ enum class SomeEnum {
 
 // Doesn't work
 fun Iterable<Int>.some() {
-    this.fold(SomeEnum.FIRST, {(res : SomeEnum, value) ->
+    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
         if (res == SomeEnum.FIRST) SomeEnum.FIRST else SomeEnum.SECOND
     })
 }
@@ -19,7 +19,7 @@ fun tempFun() : SomeEnum {
 
 // Doesn't work
 fun Iterable<Int>.someSimpleWithFun() {
-    this.fold(SomeEnum.FIRST, {(res : SomeEnum, value) ->
+    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
         tempFun()
     })
 }
@@ -27,14 +27,14 @@ fun Iterable<Int>.someSimpleWithFun() {
 
 // Works
 fun Iterable<Int>.someSimple() {
-    this.fold(SomeEnum.FIRST, {(res : SomeEnum, value) ->
+    this.fold(SomeEnum.FIRST, {res : SomeEnum, value ->
         SomeEnum.FIRST
     })
 }
 
 // Works
 fun Iterable<Int>.someInt() {
-    this.fold(0, {(res : Int, value) ->
+    this.fold(0, {res : Int, value ->
         if (res == 0) 1 else 0
     })
 }

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

@@ -15,10 +15,10 @@ fun SomeTemplate.query(f: (i: Int) -> Unit) = f
 fun SomeTemplate.query1(f: (i: Int) -> Unit) = f
 
 fun test() {
-    val mapperFunction = {(i: Int)-> }
+    val mapperFunction = { i: Int -> }
     SomeTemplate().query(mapperFunction)
 
     // TYPE_MISMATCH: Required Class<[ERROR: CANT_INFER]>, Found (kotlin.Int) -> Unit
-    SomeTemplate().query {(i: Int)-> }
+    SomeTemplate().query { i: Int -> }
-    SomeTemplate().query1 {(i: Int)-> }
+    SomeTemplate().query1 { i: Int -> }
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.kt

@@ -3,7 +3,7 @@ package a
 fun <T, R, S> foo(block: (T)-> R, <!UNUSED_PARAMETER!>second<!>: (T)-> S) = block
 
 fun main(args: Array<String>) {
-    val fff = { (x: Int) -> <!UNRESOLVED_REFERENCE!>aaa<!> }
+    val fff = { x: Int -> <!UNRESOLVED_REFERENCE!>aaa<!> }
     foo(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fff<!>, { x -> x + 1 })
 }
 

compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt

@@ -8,9 +8,9 @@ fun <T, R> bar(f: (T) -> R) = f
 fun test() {
     <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
     <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
-    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ (x: Int) -> x}<!>
+    <!TYPE_INFERENCE_TYPE_CONSTRUCTOR_MISMATCH!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
 
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
-    bar { (x: Int) -> x + 1}
+    bar { x: Int -> x + 1}
 }

compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.kt

@@ -11,7 +11,6 @@ fun inlineCallExplicitError(): String {
 
 fun inlineCall(): String {
     inlineFun @lamba {
-        (): Int ->
         if (true) {
             return@lamba 2
         }
@@ -28,7 +27,6 @@ inline fun inlineFun(s: () -> Int) {
 
 fun noInlineCall(): String {
     noInline @lambda {
-        (): Int ->
         if (true) {
             return@lambda 2
         }

compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.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.LOCAL) {
                 return@test1 Global("internal to global")
             } else if (intKind == EXT_RETURN) {

compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.kt

@@ -27,13 +27,13 @@ fun <R> fun3ValueArgument(p: () -> R) {
 
 
 fun <R> fun4(p: () -> R) {
-    inlineFun @lambda {(): R ->
+    inlineFun @lambda {
         return@lambda p();
     }
 }
 
 fun <R> fun4ValueArgument(p: () -> R) {
-    inlineFun (@lambda {(): R ->
+    inlineFun (@lambda {
         return@lambda p();
     })
 }

compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.kt

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

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

@@ -1,5 +1,5 @@
 fun nonlocals(b : Boolean) {
-    @a<!UNUSED_FUNCTION_LITERAL!>{(): Int ->
+    @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

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

@@ -2,7 +2,7 @@
 //KT-3920 Labeling information is lost when passing through some expressions
 
 fun test() {
-    run @f{ (): Int ->
+    run @f{
         val x = if (1 > 2) return@f 1 else 2
         2
     }

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

@@ -2,7 +2,7 @@
 //KT-4603 Labeling information is lost when passing through local classes or objects
 
 fun foo() {
-    val s = @l{ Int.() ->
+    val s: Int.() -> Unit = @l{
         class Local(val y: Int = this@l) {
             fun bar() {
                 val x: Int = this@l //unresolved

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

@@ -1,9 +1,9 @@
 //KT-591 Unresolved label in valid code
 
 fun test() {
-    val <!UNUSED_VARIABLE!>a<!> = @a{(Int?).() ->
+    val <!UNUSED_VARIABLE!>a<!>: (Int?).() -> Unit = @a{
         if (this != null) {
-            val <!UNUSED_VARIABLE!>b<!> = {String.() ->
+            val <!UNUSED_VARIABLE!>b<!>: String.() -> Unit = {
                 <!DEBUG_INFO_SMARTCAST!>this@a<!>.times(5) // @a Unresolved
             }
         }

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

@@ -1,7 +1,7 @@
 package jet121
 
 fun box() : String {
-val answer = apply("OK") { String.() : Int ->
+val answer = apply("OK") {
   get(0)
   length()
 }

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

@@ -1,8 +1,8 @@
-fun foo1() :  (Int) -> Int = { (x: Int) -> x }
+fun foo1() :  (Int) -> Int = { x: Int -> x }
 
 fun foo() {
   val h :  (Int) -> Int = foo1();
   h(1)
-  val m :  (Int) -> Int = {(a : Int) -> 1}//foo1()
+  val m :  (Int) -> Int = {a : Int -> 1}//foo1()
   m(1)
 }

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

@@ -4,32 +4,32 @@ package kt235
 
 fun main(args: Array<String>) {
     val array = MyArray()
-    val <!UNUSED_VARIABLE!>f<!> = { (): String ->
+    val <!UNUSED_VARIABLE!>f<!>: () -> String = {
        <!EXPECTED_TYPE_MISMATCH!>array[2] = 23<!> //error: Type mismatch: inferred type is Int (!!!) but String was expected
     }
-    val <!UNUSED_VARIABLE!>g<!> = {(): String ->
+    val <!UNUSED_VARIABLE!>g<!>: () -> String = {
        var x = 1
        <!EXPECTED_TYPE_MISMATCH!>x += 2<!>  //no error, but it should be here
     }
-    val <!UNUSED_VARIABLE!>h<!> = {(): String ->
+    val <!UNUSED_VARIABLE!>h<!>: () -> String = {
        var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>x<!> = 1
        <!EXPECTED_TYPE_MISMATCH!>x = <!UNUSED_VALUE!>2<!><!>  //the same
     }
     val array1 = MyArray1()
-    val <!UNUSED_VARIABLE!>i<!> = { (): String ->
+    val <!UNUSED_VARIABLE!>i<!>: () -> String = {
        <!EXPECTED_TYPE_MISMATCH!>array1[2] = 23<!>
     }
 
-    val <!UNUSED_VARIABLE!>fi<!> = { (): Int ->
+    val <!UNUSED_VARIABLE!>fi<!>: () -> String = {
-       <!ASSIGNMENT_TYPE_MISMATCH!>array[2] = 23<!>
+       <!EXPECTED_TYPE_MISMATCH!>array[2] = 23<!>
     }
-    val <!UNUSED_VARIABLE!>gi<!> = {(): Int ->
+    val <!UNUSED_VARIABLE!>gi<!>: () -> String = {
        var x = 1
-       <!ASSIGNMENT_TYPE_MISMATCH!>x += 21<!>
+       <!EXPECTED_TYPE_MISMATCH!>x += 21<!>
     }
 
     var m: MyNumber = MyNumber()
-    val <!UNUSED_VARIABLE!>a<!> = { (): MyNumber ->
+    val <!UNUSED_VARIABLE!>a<!>: () -> MyNumber = {
         m++
     }
 }

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

@@ -24,7 +24,7 @@ fun foo(a: A) {
         }
     }
 
-    val <!UNUSED_VARIABLE!>f<!> : () -> Int = { () : Int ->
+    val <!UNUSED_VARIABLE!>f<!> : () -> Int = {
         a.gen()  //type mismatch, but Int can be derived
     }
 

compiler/testData/diagnostics/tests/regressions/kt385.109.441.kt

@@ -17,7 +17,7 @@ fun <T> Iterable<T>.foreach(operation: (element: T) -> Unit) : Unit = iterator()
 fun <T> Iterable<T>.foreach(operation: (index: Int, element: T) -> Unit) : Unit = iterator() foreach operation
 
 fun box() : String {
-    return generic_invoker( { () : String -> "OK"} )
+    return generic_invoker( { "OK"} )
 }
 
 fun <T> generic_invoker(gen :  () -> T) : T {

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

@@ -1,7 +1,7 @@
 // KT-398 Internal error when property initializes with function
 
 class X<T>() {
-    val check = { (a : Any) -> a is <!CANNOT_CHECK_FOR_ERASED!>T<!> }
+    val check = { a : Any -> a is <!CANNOT_CHECK_FOR_ERASED!>T<!> }
 }
 
 fun box() : String {

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

@@ -1,7 +1,7 @@
 // KT-399 Type argument inference not implemented for CALL_EXPRESSION
 
 fun <T> getSameTypeChecker(<!UNUSED_PARAMETER!>obj<!>: T) : Function1<Any,Boolean> {
-    return { (a : Any) -> a is <!CANNOT_CHECK_FOR_ERASED!>T<!> }
+    return { a : Any -> a is <!CANNOT_CHECK_FOR_ERASED!>T<!> }
 }
 
 fun box() : String {

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

@@ -1,8 +1,8 @@
 package kt402
 
 fun getTypeChecker() : (Any)->Boolean {
-  <!UNUSED_FUNCTION_LITERAL!>{ (a : Any) -> a is <!UNRESOLVED_REFERENCE!>T<!> }<!> // reports unsupported
+  <!UNUSED_FUNCTION_LITERAL!>{ a : Any -> a is <!UNRESOLVED_REFERENCE!>T<!> }<!> // reports unsupported
 <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun f() : (Any) -> Boolean {
-  return { (a : Any) -> a is String }
+  return { a : Any -> a is String }
 }

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

@@ -13,7 +13,7 @@ fun invoker(<!UNUSED_PARAMETER!>gen<!> : () -> Int) : Int  = 0
 
 //more tests
 fun t1() {
-    val <!UNUSED_VARIABLE!>v<!> = @l{ () : Int ->
+    val <!UNUSED_VARIABLE!>v<!> = @l{
         return@l 111
     }
 }
@@ -41,7 +41,7 @@ fun t3() : String {
     }
     )
     invoker(
-    @l{ (): Int ->
+    @l{
         return@l 1
     }
     )
@@ -57,7 +57,7 @@ fun t4() : Int {
     val <!UNUSED_VARIABLE!>h<!> :  ()-> String = @l{
         return@l "a"
     }
-    val <!UNUSED_VARIABLE!>g<!> :  ()-> String = @l{ () : String ->
+    val <!UNUSED_VARIABLE!>g<!> :  ()-> String = @l{
         return@l "a"
     }
 

compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt

@@ -1,6 +1,6 @@
 fun test1() {
-    <!TYPE_MISMATCH!>1<!>. { String.(i: Int) -> i }(1)
+    <!TYPE_MISMATCH!>1<!>. (fun String.(i: Int) = i )(1)
-    <!TYPE_MISMATCH!>1<!>.(@label{ String.(i: Int) -> i })(1)
+    <!TYPE_MISMATCH!>1<!>.(fun String.label(i: Int) = i )(1)
 }
 
 fun test2(f: String.(Int) -> Unit) {

compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.kt

@@ -7,8 +7,8 @@ fun test() {
 
     fun bar(i: Int) = i
 
-    bar(foo(<!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(11) { (j: Int) -> j + 7 }))
+    bar(foo(<!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(11) { j: Int -> j + 7 }))
 
     bar(<!NAMED_PARAMETER_NOT_FOUND!>zz<!> = foo(
-      <!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(12) { (i: Int) -> i + i })<!NO_VALUE_FOR_PARAMETER!>)<!>
+      <!NAMED_PARAMETER_NOT_FOUND!>xx<!> = zzz(12) { i: Int -> i + i })<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInClosure.kt

@@ -1,3 +1,3 @@
 val i = 17
 
-val f = { (): Int -> var i = 17; i }
+val f: () -> Int = { var i = 17; i }

compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosure.kt

@@ -1,5 +1,5 @@
 fun f(): Int {
     var i = 17
-    <!UNUSED_FUNCTION_LITERAL!>{ (): Unit -> var <!NAME_SHADOWING, UNUSED_VARIABLE!>i<!> = 18 }<!>
+    <!UNUSED_FUNCTION_LITERAL!>{ var <!NAME_SHADOWING, UNUSED_VARIABLE!>i<!> = 18 }<!>
     return i
 }

compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosureParam.kt

@@ -1,5 +1,5 @@
 fun ff(): Int {
     var i = 1
-    <!UNUSED_FUNCTION_LITERAL!>{ (i: Int) -> i }<!>
+    <!UNUSED_FUNCTION_LITERAL!>{ i: Int -> i }<!>
     return i
 }

compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.kt

@@ -1,17 +1,16 @@
 class A(val a:Int) {
   inner class B() {
-    fun Char.xx() : Any {
+    fun Char.xx() : Double.() -> Any {
       this : Char
-      val <!UNUSED_VARIABLE!>a<!> = {
+      val <!UNUSED_VARIABLE!>a<!>: Double.() -> Unit = {
-        Double.() ->
         this : Double
         this@xx : Char
         this@B : B
         this@A : A
       }
-      val <!UNUSED_VARIABLE!>b<!> = @a{Double.() -> 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}
+      val <!UNUSED_VARIABLE!>c<!> = @a{ -> <!NO_THIS!>this@a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> this@xx : Char}
-      return (@a{Double.() -> this@a : Double + this@xx : Char})
+      return (@a{this@a : Double + this@xx : Char})
     }
   }
 }

compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.txt

@@ -12,6 +12,6 @@ internal final class A {
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-        internal final fun kotlin.Char.xx(): kotlin.Any
+        internal final fun kotlin.Char.xx(): kotlin.Double.() -> kotlin.Any
     }
 }

compiler/testData/diagnostics/testsWithStdLib/inference/arrayConstructor.kt

@@ -1,8 +1,8 @@
 package b
 
 fun bar() {
-    val a1 = Array(1, {(i: Int) -> i})
+    val a1 = Array(1, {i: Int -> i})
-    val a2 = Array(1, {(i: Int) -> "$i"})
+    val a2 = Array(1, {i: Int -> "$i"})
     val a3 = Array(1, {it})
 
     a1 : Array<Int>

idea/testData/checker/QualifiedThisInClosures.kt

@@ -5,12 +5,12 @@
         val y = this@A : A
         val z = this : B
         val Int.xx : Int get() = this : Int
-        fun Char.xx() : Any {
+        fun Char.xx() : Double.() -> Unit {
           this : Char
-          val <warning>a</warning> = {Double.() -> this : Double + this@xx : Char}
+          val <warning>a</warning>: Double.() -> Unit = { this : Double + this@xx : Char}
-          val <warning>b</warning> = @a{Double.() -> this@a : Double + this@xx : Char}
+          val <warning>b</warning>: Double.() -> Unit = @a{this@a : Double + this@xx : Char}
-          val <warning>c</warning> = @a{() -> <error>this@a</error> <error>+</error> this@xx : Char}
+          val <warning>c</warning> = @a{<error>this@a</error> <error>+</error> this@xx : Char}
-          return (@a{Double.() -> this@a : Double + this@xx : Char})
+          return (@a{this@a : Double + this@xx : Char})
         }
       }
     }

idea/testData/checker/infos/SmartCasts.kt

@@ -173,8 +173,8 @@ fun returnFunctionLiteralBlock(<info>a</info>: Any?): Function0<Int> {
     else return { 1 }
 }
 fun returnFunctionLiteral(<info>a</info>: Any?): Function0<Int> =
-    if (<info>a</info> is Int) { (): Int -> <info descr="Smart cast to kotlin.Int"><info>a</info></info> }
+    if (<info>a</info> is Int) (fun (): Int = <info descr="Smart cast to kotlin.Int"><info>a</info></info>)
-    else { () -> 1 }
+    else { -> 1 }
 
 fun mergeSmartCasts(a: Any?) {
   if (a is String || a is Int) {

idea/testData/checker/regression/Jet121.kt

@@ -1,7 +1,7 @@
 package jet121
 
 fun box(): String {
-    val answer = apply("OK") { String.(): Int ->
+    val answer = apply("OK") {
         get(0)
         length()
     }

idea/testData/checker/regression/Jet124.kt

@@ -1,8 +1,8 @@
-fun foo1() :  (Int) -> Int = { (x: Int) -> x }
+fun foo1() :  (Int) -> Int = { x: Int -> x }
 
 fun foo() {
   val h :  (Int) -> Int = foo1();
   h(1)
-  val m :  (Int) -> Int = {(a : Int) -> 1}//foo1()
+  val m :  (Int) -> Int = {a : Int -> 1}//foo1()
   m(1)
 }

idea/testData/quickfix/suppress/forStatement/unavailable/beforeInParameterTypeInFunctionLiteral.kt

@@ -4,7 +4,7 @@
 
 fun foo() {
     any {
-        (x: String?<caret>?) ->
+        x: String?<caret>? ->
     }
 }