Fixed test data for new lambda syntax

2015-03-18 00:25:06 +03:00
parent 371908a280
commit 43e24f6b0d
54 changed files with 103 additions and 113 deletions
@@ -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
    }

@@ -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)
-    1.{Int.(x : Int) -> x}(1);
+    (fun (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){Int.() -> 1}else{Int.() -> 1}()
+    1.if(true)(fun Int.() {})else{f()}()

    1.<!FUNCTION_EXPECTED!>"sdf"<!>()

@@ -71,12 +70,12 @@ fun main1() {
 }

 fun test() {
-    {(x : Int) -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
-    <!MISSING_RECEIVER!>{Int.() -> 1}<!>()
-    <!TYPE_MISMATCH!>"sd"<!>.{Int.() -> 1}()
+    {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
+    <!MISSING_RECEIVER!>(fun 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!>{}<!>()
 }
@@ -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 las = { (a: Int) -> }
+val la = { <!CANNOT_INFER_PARAMETER_TYPE!>a<!> -> }
+val las = { a: Int -> }
@@ -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<!> {}
    }
@@ -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)
    }
 }
@@ -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 {
@@ -30,7 +30,7 @@ fun test2(s : String) : Int? {
        22
    } finally {
            <!UNUSED_FUNCTION_LITERAL!>{
-            (x : Int) -> x
+            x : Int -> x
            }<!>
    }
 }
@@ -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() })
@@ -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
@@ -1,7 +1,6 @@
 fun f() {
-    foo {(): Int ->
+    foo {
        bar {
-            (): Int ->
            <!RETURN_NOT_ALLOWED!>return@foo 1<!>
        }
        return@foo 1
@@ -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"
@@ -1,5 +1,5 @@
 fun test() {
-    run1 @f{(): Int ->
+    run1 @f{
        (return@f 1)<!UNREACHABLE_CODE!>: Nothing<!>
    }
 }
@@ -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,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)
 }
@@ -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 {
@@ -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<!>())
@@ -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() {
@@ -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>
@@ -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
 }

@@ -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() {
@@ -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
    })
 }
@@ -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().query1 {(i: Int)-> }
+    SomeTemplate().query { i: Int -> }
+    SomeTemplate().query1 { i: Int -> }
 }
@@ -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 })
 }

@@ -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}
 }
@@ -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
        }
@@ -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) {
@@ -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();
    })
 }
@@ -20,7 +20,7 @@ fun <R> fun3(p: () -> R) {
 }

 fun <R> fun4(p: () -> R) {
-    Z() inlineFun @lambda {(): R ->
+    Z() inlineFun @lambda {
        return@lambda p();
    }
 }
@@ -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
@@ -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
    }
@@ -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
@@ -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
            }
        }
@@ -1,7 +1,7 @@
 package jet121

 fun box() : String {
-val answer = apply("OK") { String.() : Int ->
+val answer = apply("OK") {
  get(0)
  length()
 }
@@ -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)
 }
@@ -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 ->
-       <!ASSIGNMENT_TYPE_MISMATCH!>array[2] = 23<!>
+    val <!UNUSED_VARIABLE!>fi<!>: () -> String = {
+       <!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++
    }
 }
@@ -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
    }

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

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

 fun test2(f: String.(Int) -> Unit) {
@@ -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!>)<!>
 }
@@ -1,3 +1,3 @@
 val i = 17

-val f = { (): Int -> var i = 17; i }
+val f: () -> Int = { var i = 17; i }
@@ -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
 }
@@ -1,5 +1,5 @@
 fun ff(): Int {
    var i = 1
-    <!UNUSED_FUNCTION_LITERAL!>{ (i: Int) -> i }<!>
+    <!UNUSED_FUNCTION_LITERAL!>{ i: Int -> i }<!>
    return i
 }
@@ -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<!> = {
-        Double.() ->
+      val <!UNUSED_VARIABLE!>a<!>: Double.() -> Unit = {
        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!>c<!> = @a{() -> <!NO_THIS!>this@a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> this@xx : Char}
-      return (@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}
+      return (@a{this@a : Double + this@xx : Char})
    }
  }
 }
@@ -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
    }
 }
@@ -1,8 +1,8 @@
 package b

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

    a1 : Array<Int>
@@ -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>b</warning> = @a{Double.() -> this@a : Double + 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})
+          val <warning>a</warning>: Double.() -> Unit = { this : 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}
+          return (@a{this@a : Double + this@xx : Char})
        }
      }
    }
@@ -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> }
-    else { () -> 1 }
+    if (<info>a</info> is Int) (fun (): Int = <info descr="Smart cast to kotlin.Int"><info>a</info></info>)
+    else { -> 1 }

 fun mergeSmartCasts(a: Any?) {
  if (a is String || a is Int) {
@@ -1,7 +1,7 @@
 package jet121

 fun box(): String {
-    val answer = apply("OK") { String.(): Int ->
+    val answer = apply("OK") {
        get(0)
        length()
    }
@@ -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)
 }
@@ -4,7 +4,7 @@

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