GreatSyntacticShift: Syntax for function types, function literals, when and tuples

Bug: fun loop(var times : Int) { while(times > 0) { val u : (value : Int) -> Unit = { // This arrow is confusing the lookahead System.out?.println(it) } u(times--) } }
2011-12-20 22:55:25 +04:00
parent c9959a10f9
commit 41fd43b5e5
124 changed files with 1602 additions and 758 deletions
@@ -1,6 +1,6 @@
 // +JDK

-namespace abstract
+package abstract

 class MyClass() {
    //properties
@@ -180,7 +180,7 @@ enum class MyEnum() {

 abstract enum class MyAbstractEnum() {}

-namespace MyNamespace {
+package MyNamespace {
    //properties
    val <!MUST_BE_INITIALIZED!>a<!>: Int
    val a1: Int = 1
@@ -1,10 +1,10 @@
 fun text() {
    "direct:a" to "mock:a"
    "direct:a" on {it.body == "<hello/>"} to "mock:a"
-    "direct:a" on {it => it.body == "<hello/>"} to "mock:a"
+    "direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
    bar <!TYPE_MISMATCH!>{1}<!>
    bar <!TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!> + 1}<!>
-    bar {it, it1 => it}
+    bar {it, it1 -> it}

    bar1 {1}
    bar1 {it + 1}
@@ -12,18 +12,18 @@ fun text() {
    bar2 <!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
    bar2 {1}
    bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> => it}<!>
+    bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> it}<!>
 }

-fun bar(<!UNUSED_PARAMETER!>f<!> : fun (Int, Int) : Int) {}
-fun bar1(<!UNUSED_PARAMETER!>f<!> : fun (Int) : Int) {}
-fun bar2(<!UNUSED_PARAMETER!>f<!> : fun () : Int) {}
+fun bar(<!UNUSED_PARAMETER!>f<!> :  (Int, Int) -> Int) {}
+fun bar1(<!UNUSED_PARAMETER!>f<!> :  (Int) -> Int) {}
+fun bar2(<!UNUSED_PARAMETER!>f<!> :  () -> Int) {}

 fun String.to(<!UNUSED_PARAMETER!>dest<!> : String) {

 }

-fun String.on(<!UNUSED_PARAMETER!>predicate<!> : fun (s : URI) : Boolean) : URI {
+fun String.on(<!UNUSED_PARAMETER!>predicate<!> :  (s : URI) -> Boolean) : URI {
    return URI(this)
 }

@@ -1,6 +1,6 @@
-namespace example;
+package example;

-namespace ns {
+package ns {
    val y : Any? = 2
 }

@@ -2,7 +2,7 @@ fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1

 fun test() : Int {
    foo(<!TYPE_MISMATCH!>1<!>)
-    val <!UNUSED_VARIABLE!>a<!> : fun() : Unit = {
+    val <!UNUSED_VARIABLE!>a<!> : () -> Unit = {
        foo(<!TYPE_MISMATCH!>1<!>)
    }
    return 1 <!NONE_APPLICABLE!>-<!> "1"
@@ -1,4 +1,4 @@
-namespace boundsWithSubstitutors {
+package boundsWithSubstitutors {
    open class A<T>
    class B<X : A<X>>()

@@ -18,10 +18,10 @@ namespace boundsWithSubstitutors {
  open class A {}
  open class B<T : A>()

-  abstract class C<T : B<<!UPPER_BOUND_VIOLATED!>Int<!>>, X : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : (B<<!UPPER_BOUND_VIOLATED!>Any<!>>, B<A>)>() : B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>() { // 2 errors
+  abstract class C<T : B<<!UPPER_BOUND_VIOLATED!>Int<!>>, X :  (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) -> #(B<<!UPPER_BOUND_VIOLATED!>Any<!>>, B<A>)>() : B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>() { // 2 errors
    val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error

-    abstract val x : fun (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) : B<<!UPPER_BOUND_VIOLATED!>Any<!>>
+    abstract val x :  (B<<!UPPER_BOUND_VIOLATED!>Char<!>>) -> B<<!UPPER_BOUND_VIOLATED!>Any<!>>
  }


@@ -2,7 +2,7 @@

 import java.util.*

-namespace html {
+package html {

  abstract class Factory<T> {
    abstract fun create() : T
@@ -16,7 +16,7 @@ namespace html {
    val children = ArrayList<Element>()
    val attributes = HashMap<String, String>()

-    protected fun initTag<T : Element>(init : fun T.() : Unit) : T
+    protected fun initTag<T : Element>(init :  T.() -> Unit) : T
      where class object T : Factory<T>{
      val tag = T.create()
      tag.init()
@@ -36,9 +36,9 @@ namespace html {
      override fun create() = HTML()
    }

-    fun head(init : fun Head.() : Unit) = initTag<Head>(init)
+    fun head(init :  Head.() -> Unit) = initTag<Head>(init)

-    fun body(init : fun Body.() : Unit) = initTag<Body>(init)
+    fun body(init :  Body.() -> Unit) = initTag<Body>(init)
  }

  class Head() : TagWithText("head") {
@@ -46,7 +46,7 @@ namespace html {
      override fun create() = Head()
    }

-    fun title(init : fun Title.() : Unit) = initTag<Title>(init)
+    fun title(init :  Title.() -> Unit) = initTag<Title>(init)
  }

  class Title() : TagWithText("title")
@@ -59,10 +59,10 @@ namespace html {
      override fun create() = Body()
    }

-    fun b(init : fun B.() : Unit) = initTag<B>(init)
-    fun p(init : fun P.() : Unit) = initTag<P>(init)
-    fun h1(init : fun H1.() : Unit) = initTag<H1>(init)
-    fun a(href : String, init : fun A.() : Unit) {
+    fun b(init :  B.() -> Unit) = initTag<B>(init)
+    fun p(init :  P.() -> Unit) = initTag<P>(init)
+    fun h1(init :  H1.() -> Unit) = initTag<H1>(init)
+    fun a(href : String, init :  A.() -> Unit) {
      val a = initTag<A>(init)
      a.href = href
    }
@@ -79,7 +79,7 @@ namespace html {

  fun Map<String, String>.set(key : String, value : String) = this.put(key, value)

-  fun html(init : fun HTML.() : Unit) : HTML {
+  fun html(init :  HTML.() -> Unit) : HTML {
    val html = HTML()
    html.init()
    return html
@@ -87,7 +87,7 @@ namespace html {

 }

-namespace foo {
+package foo {

 import html.*

@@ -12,5 +12,5 @@ fun test() : Unit {
  y <!USELESS_CAST!>as?<!> Int : Int?
  x <!USELESS_CAST!>as?<!> Int? : Int?
  y <!USELESS_CAST_STATIC_ASSERT_IS_FINE!>as?<!> Int? : Int?
-  ()
+  #()
 }
@@ -1,6 +1,6 @@
 // +JDK

-namespace Jet86
+package Jet86

 class A {
  class object {
@@ -13,7 +13,7 @@ class A {
    }
 }

-namespace deepSpace {
+package deepSpace {
    <!CONFLICTING_OVERLOADS!>fun c(<!UNUSED_PARAMETER!>s<!>: String)<!> {
    }

@@ -32,23 +32,23 @@ namespace deepSpace {

 // check no error in overload in different namespaces

-namespace ns1 {
+package ns1 {
    fun e() = 1
 }

-namespace ns2 {
+package ns2 {
    fun e() = 1
 }

-namespace ns3 {
-    namespace ns1 {
+package ns3 {
+    package ns1 {
        fun e() = 1
    }
 }

 // check same rules apply for ext functions

-namespace extensionFunctions {
+package extensionFunctions {
    <!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 1
    
    <!CONFLICTING_OVERLOADS!>fun Int.qwe(<!UNUSED_PARAMETER!>a<!>: Float)<!> = 2
@@ -60,7 +60,7 @@ namespace extensionFunctions {

 // check no error when regular function and extension function have same name

-namespace extensionAndRegular {
+package extensionAndRegular {
    fun who() = 1
    
    fun Int.who() = 1
@@ -68,7 +68,7 @@ namespace extensionAndRegular {

 // constructor vs. fun overload

-namespace constructorVsFun {
+package constructorVsFun {
    class <!CONFLICTING_OVERLOADS!>a()<!> { }

    <!CONFLICTING_OVERLOADS!>fun a()<!> = 1
@@ -1,4 +1,4 @@
-namespace dollar
+package dollar

 open class `$$$$$`() {
 }
@@ -1,7 +1,7 @@
 // +JDK

 fun Int?.optint() : Unit {}
-val Int?.optval : Unit = ()
+val Int?.optval : Unit = #()

 fun <T, E> T.foo(<!UNUSED_PARAMETER!>x<!> : E, y : A) : T   {
  y.plus(1)
@@ -39,7 +39,7 @@ val <T> T.<!MUST_BE_INITIALIZED!>foo<!> : T

 fun Int.foo() = this

-namespace null_safety {
+package null_safety {

        fun parse(<!UNUSED_PARAMETER!>cmd<!>: String): Command? { return null  }
        class Command() {
@@ -1,22 +1,22 @@
-namespace foo
+package foo

-fun Any.foo() : fun() : Unit {
+fun Any.foo() : () -> Unit {
  return {}
 }

-fun Any.foo1() : fun(i : Int) : Unit {
+fun Any.foo1() : (i : Int) -> Unit {
  return {}
 }

-fun foo2() : fun(i : fun()) : Unit {
+fun foo2() : (i : () -> Unit) -> Unit {
  return {}
 }

-fun fooT1<T>(t : T) : fun() : T {
+fun fooT1<T>(t : T) : () -> T {
  return {t}
 }

-fun fooT2<T>() : fun(t : T) : T {
+fun fooT2<T>() : (t : T) -> T {
  return {it}
 }

@@ -34,8 +34,8 @@ fun main(args : Array<String>) {
    foo2()({})
    foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
    (foo2()){}
-    (foo2())<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> => }<!>
-    foo2()(<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> => }<!>)
+    (foo2())<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }<!>
+    foo2()(<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }<!>)

    val a = fooT1(1)()
    a : Int
@@ -49,19 +49,19 @@ fun main(args : Array<String>) {
    <!CALLEE_NOT_A_FUNCTION!>1<!>(){}
 }

-fun f() : fun Int.() : Unit = {}
+fun f() :  Int.() -> Unit = {}

 fun main1() {
-    1.{Int.() => 1}();
+    1.{Int.() -> 1}();
    {1}()
-    {(x : Int) => x}(1)
-    1.{Int.(x : Int) => x}(1)
+    {(x : Int) -> x}(1)
+    1.{Int.(x : Int) -> x}(1)
    @l{1}()
-    1.({Int.() => 1})()
+    1.({Int.() -> 1})()
    1.(f())()
    1.if(true){f()}else{f()}()
-    1.if(true){Int.() => 1}else{f()}()
-    1.if(true){Int.() => 1}else{Int.() => 1}()
+    1.if(true){Int.() -> 1}else{f()}()
+    1.if(true){Int.() -> 1}else{Int.() -> 1}()

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

@@ -71,12 +71,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!>{Int.() -> 1}<!>()
+    <!TYPE_MISMATCH!>"sd"<!>.{Int.() -> 1}()
    val i : Int? = null
-    i<!UNSAFE_CALL!>.<!>{Int.() => 1}()
+    i<!UNSAFE_CALL!>.<!>{Int.() -> 1}()
    {}<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>()
-    1<!UNNECESSARY_SAFE_CALL!>?.<!>{Int.() => 1}()
+    1<!UNNECESSARY_SAFE_CALL!>?.<!>{Int.() -> 1}()
    1.<!NO_RECEIVER_ADMITTED!>{}<!>()
 }
@@ -6,11 +6,11 @@ fun unitEmptyInfer() {}
 fun unitEmpty() : Unit {}
 fun unitEmptyReturn() : Unit {return}
 fun unitIntReturn() : Unit {return <!TYPE_MISMATCH!>1<!>}
-fun unitUnitReturn() : Unit {return ()}
+fun unitUnitReturn() : Unit {return #()}
 fun test1() : Any = {<!RETURN_TYPE_MISMATCH, RETURN_NOT_ALLOWED!>return<!>}
 fun test2() : Any = @a {return@a 1}
 fun test3() : Any { <!RETURN_TYPE_MISMATCH!>return<!> }
-fun test4(): fun(): Unit = { <!RETURN_TYPE_MISMATCH, RETURN_NOT_ALLOWED!>return@test4<!> }
+fun test4(): ()-> Unit = { <!RETURN_TYPE_MISMATCH, RETURN_NOT_ALLOWED!>return@test4<!> }
 fun test5(): Any = @{ return@ }
 fun test6(): Any = {<!RETURN_NOT_ALLOWED!>return 1<!>}

@@ -21,13 +21,13 @@ fun bbb() {
 fun foo(<!UNUSED_PARAMETER!>expr<!>: StringBuilder): Int {
  val c = 'a'
  when(c) {
-    0.chr => throw Exception("zero")
-    else => throw Exception("nonzero" + c)
+    0.chr -> throw Exception("zero")
+    else -> throw Exception("nonzero" + c)
  }
 }


-fun unitShort() : Unit = ()
+fun unitShort() : Unit = #()
 fun unitShortConv() : Unit = <!TYPE_MISMATCH!>1<!>
 fun unitShortNull() : Unit = <!TYPE_MISMATCH!>null<!>

@@ -44,7 +44,7 @@ fun intFunctionLiteral(): Int = <!TYPE_MISMATCH!>{ 10 }<!>
 fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
 fun blockReturnValueTypeMismatch() : Int {return <!ERROR_COMPILE_TIME_VALUE!>3.4<!>}
 fun blockReturnValueTypeMatch() : Int {return 1}
-fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>()<!>}
+fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>#()<!>}

 fun blockAndAndMismatch() : Int {
  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>true && false<!>
@@ -176,37 +176,37 @@ class B() {
 }

 fun testFunctionLiterals() {
-    val <!UNUSED_VARIABLE!>endsWithVarDeclaration<!> : fun() : Boolean = {
+    val <!UNUSED_VARIABLE!>endsWithVarDeclaration<!> : () -> Boolean = {
        <!EXPECTED_TYPE_MISMATCH!>val x = 2<!>
    }

-    val <!UNUSED_VARIABLE!>endsWithAssignment<!> = { () : Int =>
+    val <!UNUSED_VARIABLE!>endsWithAssignment<!> = { () : Int ->
        var x = 1
        <!EXPECTED_TYPE_MISMATCH!>x = 333<!>
    }

-    val <!UNUSED_VARIABLE!>endsWithReAssignment<!> = { () : Int =>
+    val <!UNUSED_VARIABLE!>endsWithReAssignment<!> = { () : Int ->
        var x = 1
        <!ASSIGNMENT_TYPE_MISMATCH!>x += 333<!>
    }

-    val <!UNUSED_VARIABLE!>endsWithFunDeclaration<!> : fun() : String = {
+    val <!UNUSED_VARIABLE!>endsWithFunDeclaration<!> : () -> String = {
        var x = 1
        x = 333
        <!EXPECTED_TYPE_MISMATCH!>fun meow() : Unit {}<!>
    }

-    val <!UNUSED_VARIABLE!>endsWithObjectDeclaration<!> : fun() : Int = {
+    val <!UNUSED_VARIABLE!>endsWithObjectDeclaration<!> : () -> Int = {
        var x = 1
        x = 333
        <!EXPECTED_TYPE_MISMATCH!>object A {}<!>
    }

-    val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!> = { () : Unit =>
+    val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!> = { () : Unit ->
        val x = 1
    }

-    val <!UNUSED_VARIABLE!>expectedUnitReturnType2<!> = { () : Unit =>
+    val <!UNUSED_VARIABLE!>expectedUnitReturnType2<!> = { () : Unit ->
        fun meow() : Unit {}
        object A {}
    }
@@ -13,28 +13,28 @@ trait BB1 : BA1<Int> {}
 trait BB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>BA1<Any>, BB1<!> {}


-namespace x {
+package x {
    trait AA1<out T> {}
    trait AB1 : AA1<Int> {}
    trait AB3 : AA1<Comparable<Int>> {}
    trait AB2 : AA1<Number>, AB1, AB3 {}
 }

-namespace x2 {
+package x2 {
    trait AA1<out T> {}
    trait AB1 : AA1<Any> {}
    trait AB3 : AA1<Comparable<Int>> {}
    trait AB2 : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>AA1<Number>, AB1, AB3<!> {}
 }

-namespace x3 {
+package x3 {
    trait AA1<in T> {}
    trait AB1 : AA1<Any> {}
    trait AB3 : AA1<Comparable<Int>> {}
    trait AB2 : AA1<Number>, AB1, AB3 {}
 }

-namespace sx2 {
+package sx2 {
    trait AA1<in T> {}
    trait AB1 : AA1<Int> {}
    trait AB3 : AA1<Comparable<Int>> {}
@@ -1,4 +1,4 @@
-namespace illegal_modifiers
+package illegal_modifiers

 abstract class A() {
    <!INCOMPATIBLE_MODIFIERS!>abstract<!> <!INCOMPATIBLE_MODIFIERS!>final<!> fun f()
@@ -1,22 +1,22 @@
 // KT-355 Resolve imports after all symbols are built

-namespace a {
+package a {
  import b.*
  val x : X = X()
 }

-namespace b {
+package b {
  class X() {

  }
 }

-namespace c {
+package c {
  import d.X
  val x : X = X()
 }

-namespace d {
+package d {
  class X() {

  }
@@ -1,4 +1,4 @@
-namespace lvalue_assignment
+package lvalue_assignment

 open class B() {
    var b: Int = 2
@@ -38,7 +38,7 @@ class D() {

 fun cannotBe(var <!UNUSED_PARAMETER!>i<!>: Int) {
    <!UNRESOLVED_REFERENCE!>z<!> = 30;
-    <!VARIABLE_EXPECTED!>()<!> = ();
+    <!VARIABLE_EXPECTED!>#()<!> = #();

    (<!VARIABLE_EXPECTED!>i <!USELESS_CAST!>as<!> Int<!>) = 34
    (<!VARIABLE_EXPECTED!>i is Int<!>) = false
@@ -2,7 +2,7 @@
 // KT-689 Allow to put Java and Kotlin files in the same packages

 // This is a stub test. One should not extend Java packages that come from libraries.
-namespace java
+package java

 val c : lang.Class<*>? = null

@@ -1,4 +1,4 @@
-namespace Jet87
+package Jet87

 open class A() {
  fun foo() : Int = 1
@@ -1,6 +1,6 @@
-namespace root
+package root

-namespace a {
+package a {

 }

@@ -1,6 +1,6 @@
 // +JDK

-namespace foo
+package foo

 class X {}

@@ -1,8 +1,8 @@
 // +JDK

-namespace foobar
+package foobar

-namespace a {
+package a {
    import java.*

    val a : util.List<Int>? = null
@@ -14,7 +14,7 @@ abstract class Foo<T>() {
    abstract val x : T<Int>
 }

-namespace a {
+package a {
    import java.util.*

    val b : List<Int>? = a
@@ -40,28 +40,28 @@ fun test() {
    out.println();
  }

-  if (out == null || out.println(0) == ()) {
+  if (out == null || out.println(0) == #()) {
    out?.println(1)
  }
  else {
    out.println(2)
  }

-  if (out != null && out.println() == ()) {
+  if (out != null && out.println() == #()) {
    out.println();
  }
  else {
    out?.println();
  }

-  if (out == null || out != null && out.println() == ()) {
+  if (out == null || out != null && out.println() == #()) {
    out?.println();
  }
  else {
    out.println();
  }

-  if (1 == 2 || out != null && out.println(1) == ()) {
+  if (1 == 2 || out != null && out.println(1) == #()) {
    out?.println(2);
  }
  else {
@@ -96,28 +96,28 @@ fun test() {
    out.println();
  }

-  if (out == null || out.println(0) == ()) {
+  if (out == null || out.println(0) == #()) {
    out?.println(1)
  }
  else {
    out.println(2)
  }

-  if (out != null && out.println() == ()) {
+  if (out != null && out.println() == #()) {
    out.println();
  }
  else {
    out?.println();
  }

-  if (out == null || out != null && out.println() == ()) {
+  if (out == null || out != null && out.println() == #()) {
    out?.println();
  }
  else {
    out.println();
  }

-  if (1 == 2 || out != null && out.println(1) == ()) {
+  if (1 == 2 || out != null && out.println(1) == #()) {
    out?.println(2);
  }
  else {
@@ -1,4 +1,4 @@
-namespace toplevelObjectDeclarations {
+package toplevelObjectDeclarations {
  open class Foo(y : Int) {
    open fun foo() : Int = 1
  }
@@ -28,7 +28,7 @@ namespace toplevelObjectDeclarations {
  val z = y.foo()
 }

-namespace nestedObejcts {
+package nestedObejcts {
  object A {
    val b = B
    val d = A.B.A
@@ -58,7 +58,7 @@ namespace nestedObejcts {
  val e = B.<!UNRESOLVED_REFERENCE!>A<!>.B
 }

-namespace localObjects {
+package localObjects {
  object A {
    val x : Int = 0
  }
@@ -1,6 +1,6 @@
-namespace override
+package override

-namespace normal {
+package normal {
    trait MyTrait {
        fun foo()
        val pr : Unit
@@ -16,8 +16,8 @@ namespace normal {
        override fun foo() {}
        override fun bar() {}

-        override val pr : Unit = ()
-        override val prr : Unit = ()
+        override val pr : Unit = #()
+        override val prr : Unit = #()
    }

    class MyChildClass() : MyClass() {}
@@ -26,14 +26,14 @@ namespace normal {

    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!>() : MyTrait, MyAbstractClass {
        override fun foo() {}
-        override val pr : Unit = ()
-        override val prr : Unit = ()
+        override val pr : Unit = #()
+        override val prr : Unit = #()
    }

    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass3<!>() : MyTrait, MyAbstractClass {
        override fun bar() {}
-        override val pr : Unit = ()
-        override val prr : Unit = ()
+        override val pr : Unit = #()
+        override val prr : Unit = #()
    }

    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass4<!>() : MyTrait, MyAbstractClass {
@@ -45,13 +45,13 @@ namespace normal {

    class MyChildClass1() : MyClass() {
        fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>() {}
-        val <!VIRTUAL_MEMBER_HIDDEN!>pr<!> : Unit = ()
+        val <!VIRTUAL_MEMBER_HIDDEN!>pr<!> : Unit = #()
        override fun bar() {}
-        override val prr : Unit = ()
+        override val prr : Unit = #()
    }
 }

-namespace generics {
+package generics {
    trait MyTrait<T> {
        fun foo(t: T) : T
    }
@@ -1,4 +1,4 @@
-namespace qualified_expressions
+package qualified_expressions

 fun test(s: String?) {
   val <!UNUSED_VARIABLE!>a<!>: Int = <!TYPE_MISMATCH!>s?.length<!>
@@ -21,7 +21,7 @@ fun foo1() : Unit {
  this<!UNRESOLVED_REFERENCE!>@a<!>
 }

-namespace closures {
+package closures {
    class A(val a:Int) {

      class B() {
@@ -31,10 +31,10 @@ namespace closures {
        val Int.xx = this : Int
        fun Char.xx() : Any {
          this : Char
-          val <!UNUSED_VARIABLE!>a<!> = {Double.() => this : Double + this@xx : Char}
-          val <!UNUSED_VARIABLE!>b<!> = @a{Double.() => this@a : Double + this@xx : Char}
-          val <!UNUSED_VARIABLE!>c<!> = @a{() => <!NO_THIS!>this@a<!> + this@xx : Char}
-          return (@a{Double.() => this@a : Double + this@xx : Char})
+          val <!UNUSED_VARIABLE!>a<!> = {Double.() -> this : Double + this@xx : Char}
+          val <!UNUSED_VARIABLE!>b<!> = @a{Double.() -> this@a : Double + this@xx : Char}
+          val <!UNUSED_VARIABLE!>c<!> = @a{() -> <!NO_THIS!>this@a<!> + this@xx : Char}
+          return (@a{Double.() -> this@a : Double + this@xx : Char})
        }
      }
    }
@@ -1,16 +1,16 @@
-namespace a {
+package a {
    val foo = bar()

    fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
 }

-namespace b {
+package b {
    fun foo() = bar()

    fun bar() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo()<!>
 }

-namespace c {
+package c {
    fun bazz() = bar()

    fun foo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bazz()<!>
@@ -18,21 +18,21 @@ namespace c {
    fun bar() = foo()
 }

-namespace ok {
+package ok {

-    namespace a {
+    package a {
        val foo = bar()

        fun bar() : Int = foo
    }

-    namespace b {
+    package b {
        fun foo() : Int = bar()

        fun bar() = foo()
    }

-    namespace c {
+    package c {
        fun bazz() = bar()

        fun foo() : Int = bazz()
@@ -1,11 +1,11 @@
-namespace redeclarations {
+package redeclarations {
  object <!REDECLARATION, REDECLARATION!>A<!> {
    val x : Int = 0

    val A = 1
  }

-  namespace <!REDECLARATION!>A<!> {
+  package <!REDECLARATION!>A<!> {
    class A {}
  }

@@ -49,6 +49,6 @@ fun test(<!UNUSED_PARAMETER!>l<!> : java.util.List<Int>) {
 }


-namespace xxx {
+package xxx {
  import java.lang.Class;
 }
@@ -1,4 +1,4 @@
-namespace <!SYNTAX!>return<!>
+package <!SYNTAX!>return<!>

 class A {
    fun outer() {
@@ -0,0 +1,51 @@
+class A {
+}
+
+namespace n {
+  class B
+}
+abstract class XXX() {
+    abstract val a : Int
+    abstract val a1 : namespace.<!UNRESOLVED_REFERENCE!>Int<!>
+    abstract val a2 : n.B
+    abstract val a3 : (A)
+    abstract val a31 : (n.B)
+    abstract val a4 : A?
+    abstract val a5 : (A)?
+    abstract val a6 : (A?)
+    abstract val a7 : (A) -> n.B
+    abstract val a8 : (A, n.B) -> n.B
+
+//val a9 : (A, B)
+//val a10 : (B)? -> B
+
+    val a11 : ((Int) -> Int)? = null
+    val a12 : ((Int) -> (Int))? = null
+    abstract val a13 : Int.(Int) -> Int
+    abstract val a14 : n.B.(Int) -> Int
+    abstract val a15 : Int? .(Int) -> Int
+    abstract val a152 : (Int?).(Int) -> Int
+    abstract val a151 : Int?.(Int) -> Int
+    abstract val a16 : (Int) -> (Int) -> Int
+    abstract val a17 : ((Int) -> Int).(Int) -> Int
+    abstract val a18 : (Int) -> ((Int) -> Int)
+    abstract val a19 : ((Int) -> Int) -> Int
+}
+
+abstract class YYY() {
+    abstract val a7 : (a : A) -> n.B
+    abstract val a8 : (a : A, b : n.B) -> n.B
+//val a9 : (A, B)
+//val a10 : (B)? -> B
+    val a11 : ((a : Int) -> Int)? = null
+    val a12 : ((a : Int) -> (Int))? = null
+    abstract val a13 : Int.(a : Int) -> Int
+    abstract val a14 : n.B.(a : Int) -> Int
+    abstract val a15 : Int? .(a : Int) -> Int
+    abstract val a152 : (Int?).(a : Int) -> Int
+abstract val a151 : Int?.(a : Int) -> Int
+    abstract val a16 : (a : Int) -> (a : Int) -> Int
+    abstract val a17 : ((a : Int) -> Int).(a : Int) -> Int
+    abstract val a18 : (a : Int) -> ((a : Int) -> Int)
+    abstract val a19 : (b : (a : Int) -> Int) -> Int
+}
@@ -3,8 +3,8 @@ fun demo() {
  val a = ""
  val asd = 1
  val bar = 5
-  fun map(f : fun () : Any?) : Int  = 1
-  fun buzz(f : fun () : Any?) : Int  = 1
+  fun map(f :  () -> Any?) : Int  = 1
+  fun buzz(f :  () -> Any?) : Int  = 1
  val sdf = 1
  val foo = 3;
    "$abc"
@@ -1,4 +1,4 @@
-namespace example;
+package example;

 fun any(<!UNUSED_PARAMETER!>a<!> : Any) {}

@@ -7,7 +7,7 @@ fun notAnExpression() {
    if (<!SUPER_IS_NOT_AN_EXPRESSION!>super<!>) {} else {} // not an expression
    val <!UNUSED_VARIABLE!>x<!> = <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> // not an expression
    when (1) {
-        <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> => 1 // not an expression
+        <!SUPER_IS_NOT_AN_EXPRESSION!>super<!> -> 1 // not an expression
    }

 }
@@ -33,8 +33,8 @@ class A<E>() : C(), T {
        super<<!NOT_A_SUPERTYPE!>E<!>>@A.bar()
        super<<!NOT_A_SUPERTYPE!>Int<!>>.foo()
        super<<!SYNTAX!><!>>.foo()
-        super<<!NOT_A_SUPERTYPE!>fun() : Unit<!>>.foo()
-        super<<!NOT_A_SUPERTYPE!>()<!>>.foo()
+        super<<!NOT_A_SUPERTYPE!>() -> Unit<!>>.foo()
+        super<<!NOT_A_SUPERTYPE!>#()<!>>.foo()
        super<T><!UNRESOLVED_REFERENCE!>@B<!>.foo()
        super<C><!UNRESOLVED_REFERENCE!>@B<!>.bar()
    }
@@ -1,4 +1,4 @@
-namespace uninitialized_reassigned_variables
+package uninitialized_reassigned_variables

 fun doSmth(<!UNUSED_PARAMETER!>s<!>: String) {}
 fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
@@ -1,3 +1,3 @@
-fun foo(f : fun()) {
+fun foo(f : () -> Unit) {
    val <!UNUSED_VARIABLE!>x<!> : Unit = f()
 }
@@ -1,8 +1,8 @@
-namespace unresolved
+package unresolved

 fun testGenericArgumentsCount() {
-    val <!UNUSED_VARIABLE!>p1<!>: Tuple2<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = (2, 2)
-    val <!UNUSED_VARIABLE!>p2<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Tuple2<!> = (2, 2)
+    val <!UNUSED_VARIABLE!>p1<!>: Tuple2<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!> = #(2, 2)
+    val <!UNUSED_VARIABLE!>p2<!>: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Tuple2<!> = #(2, 2)
 }

 fun testUnresolved() {
@@ -16,8 +16,8 @@ fun testUnresolved() {
    s.<!UNRESOLVED_REFERENCE!>foo<!>()

    when(<!UNRESOLVED_REFERENCE!>a<!>) {
-        is Int => <!UNRESOLVED_REFERENCE!>a<!>
-        is String => <!UNRESOLVED_REFERENCE!>a<!>
+        is Int -> <!UNRESOLVED_REFERENCE!>a<!>
+        is String -> <!UNRESOLVED_REFERENCE!>a<!>
    }

    //TODO
@@ -1,4 +1,4 @@
-namespace unused_variables
+package unused_variables

 fun testSimpleCases() {
    var i = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>2<!>
@@ -103,11 +103,11 @@ fun testInnerFunctions() {

 fun testFunctionLiterals() {
    var x = 1
-    var <!UNUSED_VARIABLE!>fl<!> = { (): Int =>
+    var <!UNUSED_VARIABLE!>fl<!> = { (): Int ->
        x
    }
    var y = 2
-    var <!UNUSED_VARIABLE!>fl1<!> = { (): Unit =>
+    var <!UNUSED_VARIABLE!>fl1<!> = { (): Unit ->
        doSmth(y)
    }
 }
@@ -1,5 +1,5 @@
 fun v(<!UNUSED_PARAMETER!>x<!> : Int, <!UNUSED_PARAMETER!>y<!> : String, vararg <!UNUSED_PARAMETER!>f<!> : Long) {}
-fun v1(vararg <!UNUSED_PARAMETER!>f<!> : fun (Int) : Unit) {}
+fun v1(vararg <!UNUSED_PARAMETER!>f<!> :  (Int) -> Unit) {}

 fun test() {
    v(1, "")
@@ -1,4 +1,4 @@
-namespace variance
+package variance

 abstract class Consumer<in T> {}

@@ -4,19 +4,19 @@ fun foo() : Int {
    val s = ""
    val x = 1
    when (x) {
-      is * => 1
-      is <!INCOMPATIBLE_TYPES!>String<!> => 1
-      !is Int => 1
-      is Any? => 1
-      <!INCOMPATIBLE_TYPES!>s<!> => 1
-      1 => 1
-      1 + <!UNRESOLVED_REFERENCE!>a<!> => 1
-      in 1..<!UNRESOLVED_REFERENCE!>a<!> => 1
-      !in 1..<!UNRESOLVED_REFERENCE!>a<!> => 1
+      is * -> 1
+      is <!INCOMPATIBLE_TYPES!>String<!> -> 1
+      !is Int -> 1
+      is Any? -> 1
+      <!INCOMPATIBLE_TYPES!>s<!> -> 1
+      1 -> 1
+      1 + <!UNRESOLVED_REFERENCE!>a<!> -> 1
+      in 1..<!UNRESOLVED_REFERENCE!>a<!> -> 1
+      !in 1..<!UNRESOLVED_REFERENCE!>a<!> -> 1
      // Commented for KT-621 .<!!UNRESOLVED_REFERENCE!>a<!!> => 1
      // Commented for KT-621 .equals(1).<!!UNRESOLVED_REFERENCE!>a<!!> => 1
      // Commented for KT-621 <!UNNECESSARY_SAFE_CALL!!>?.<!!>equals(1) => 1
-      else => 1
+      else -> 1
    }

    // Commented for KT-621
@@ -35,33 +35,33 @@ fun test() {
  val s = "";

  when (x) {
-    <!INCOMPATIBLE_TYPES!>s<!> => 1
-    is <!INCOMPATIBLE_TYPES!>""<!> => 1
-    x => 1
-    is 1 => 1
-    is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, 1)<!> => 1
+    <!INCOMPATIBLE_TYPES!>s<!> -> 1
+    is <!INCOMPATIBLE_TYPES!>""<!> -> 1
+    x -> 1
+    is 1 -> 1
+    is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>#(1, 1)<!> -> 1
  }

-  val z = (1, 1)
+  val z = #(1, 1)

  when (z) {
-    is (*, *) => 1
-    is (*, 1) => 1
-    is (1, 1) => 1
-    is (1, <!INCOMPATIBLE_TYPES!>"1"<!>) => 1
-    is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, "1", *)<!> => 1
-    is boo @ (1, <!INCOMPATIBLE_TYPES!>"a"<!>, *) => 1
-    is boo @ <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>(1, *)<!> => 1
+    is #(*, *) -> 1
+    is #(*, 1) -> 1
+    is #(1, 1) -> 1
+    is #(1, <!INCOMPATIBLE_TYPES!>"1"<!>) -> 1
+    is <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>#(1, "1", *)<!> -> 1
+    is boo  #(1, <!INCOMPATIBLE_TYPES!>"a"<!>, *) -> 1
+    is boo  <!TYPE_MISMATCH_IN_TUPLE_PATTERN!>#(1, *)<!> -> 1
  }

  when (z) {
-    <!ELSE_MISPLACED_IN_WHEN!>else => 1<!>
-    (1, 1) => 2
+    <!ELSE_MISPLACED_IN_WHEN!>else -> 1<!>
+    #(1, 1) -> 2
  }

  when (z) {
-    else => 1
+    else -> 1
  }
 }

-val (Int, Int).boo : (Int, Int, Int) = (1, 1, 1)
+val #(Int, Int).boo : #(Int, Int, Int) = #(1, 1, 1)
@@ -1,4 +1,4 @@
-namespace customGetValGlobal {
+package customGetValGlobal {
    val zz = 1
        get() = $zz * 2
    
@@ -1,7 +1,7 @@
 //KT-462 Consider allowing initializing properties via property names when it is safe
 //KT-598 Allow to use backing fields after this expression

-namespace kt462
+package kt462

 abstract class TestInitializationWithoutBackingField() {
    val valWithBackingField : Int
@@ -1,6 +1,6 @@
 // KT-782 Allow backing field usage for accessors of variables on namespace level

-namespace kt782
+package kt782

 val z : Int = 34

@@ -3,6 +3,6 @@
 import java.util.List;

 fun ff(l: Any) = when(l) {
-    is <!CANNOT_CHECK_FOR_ERASED!>List<String><!> => 1
+    is <!CANNOT_CHECK_FOR_ERASED!>List<String><!> -> 1
    else <!SYNTAX!>2<!>
 }
@@ -1,6 +1,6 @@
 //KT-510 `this.` allows initialization without backing field

-namespace kt510
+package kt510

 public open class Identifier1() {
    var field : Boolean
@@ -1,6 +1,6 @@
 //KT-607 Val reassignment is not marked as an error

-namespace kt607
+package kt607

 fun foo(a: A) {
    val o = object {
@@ -1,6 +1,6 @@
 //KT-609 Analyze not only local variables, but function parameters as well in 'unused values' analysis

-namespace kt609
+package kt609

 fun test(var a: Int) {
    a = <!UNUSED_VALUE!>324<!> //should be an 'unused value' warning here
@@ -1,6 +1,6 @@
 //KT-610 Distinguish errors 'unused variable' and 'variable is assigned but never accessed'

-namespace kt610
+package kt610

 fun foo() {
    var <!UNUSED_VARIABLE!>j<!> = 9  //'unused variable' error
@@ -1,6 +1,6 @@
 //KT-843 Don't highlight incomplete variables as unused

-namespace kt843
+package kt843

 fun main(args : Array<String>) {
    // Integer type
@@ -1,4 +1,4 @@
-namespace kt770_351_735
+package kt770_351_735

 //+JDK

@@ -6,9 +6,9 @@ namespace kt770_351_735
 fun main(args : Array<String>) {
    var i = 0
    when (i) {
-        1 => i--
-        2 => i = 2  // i is surrounded by a black border
-        else => <!UNRESOLVED_REFERENCE!>j<!> = 2
+        1 -> i--
+        2 -> i = 2  // i is surrounded by a black border
+        else -> <!UNRESOLVED_REFERENCE!>j<!> = 2
    }
    System.out?.println(i)
 }
@@ -26,8 +26,8 @@ fun foo() {
            z = <!UNUSED_VALUE!>34<!>
        }
    }
-    val <!UNUSED_VARIABLE!>f<!>: fun(): Int = <!TYPE_MISMATCH!>r<!>
-    val <!UNUSED_VARIABLE!>g<!>: fun(): Any = r
+    val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!TYPE_MISMATCH!>r<!>
+    val <!UNUSED_VARIABLE!>g<!>: ()-> Any = r
 }

 //KT-735 Statements without braces are prohibited on the right side of when entries.
@@ -35,8 +35,8 @@ fun box() : Int {
    val d = 2
    var z = 0
        when(d) {
-        is 5, is 3 => z++
-        else => z = -1000
+        is 5, is 3 -> z++
+        else -> z = -1000
    }
    return z
 }
@@ -47,10 +47,10 @@ fun test1() = while(true) {}
 fun test2(): Unit = while(true) {}

 fun testCoercionToUnit() {
-    val <!UNUSED_VARIABLE!>simple<!>: fun(): Unit = {
+    val <!UNUSED_VARIABLE!>simple<!>: ()-> Unit = {
        41
    }
-    val <!UNUSED_VARIABLE!>withIf<!>: fun(): Unit = {
+    val <!UNUSED_VARIABLE!>withIf<!>: ()-> Unit = {
        if (true) {
            3
        } else {
@@ -58,16 +58,16 @@ fun testCoercionToUnit() {
        }
    }
    val i = 34
-    val <!UNUSED_VARIABLE!>withWhen<!> : fun() : Unit = {
+    val <!UNUSED_VARIABLE!>withWhen<!> : () -> Unit = {
        when(i) {
-            is 1 => {
+            is 1 -> {
                val d = 34
                "1"
                doSmth(d)

            }
-            is 2 => '4'
-            else => true
+            is 2 -> '4'
+            else -> true
        }
    }

@@ -79,7 +79,7 @@ fun testCoercionToUnit() {
            45
        }
    }
-    val <!UNUSED_VARIABLE!>f<!> : fun() : String = <!TYPE_MISMATCH!>checkType<!>
+    val <!UNUSED_VARIABLE!>f<!> : () -> String = <!TYPE_MISMATCH!>checkType<!>
 }

 fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
@@ -88,16 +88,16 @@ fun testImplicitCoercion() {
    val d = 21
    var z = 0
    var <!UNUSED_VARIABLE!>i<!> = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>when(d) {
-        is 3 => null
-        is 4 => { val <!NAME_SHADOWING, UNUSED_VARIABLE!>z<!> = 23 }
-        else => z = 20
+        is 3 -> null
+        is 4 -> { val <!NAME_SHADOWING, UNUSED_VARIABLE!>z<!> = 23 }
+        else -> z = 20
    }<!>

    var <!UNUSED_VARIABLE!>u<!> = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>when(d) {
-        is 3 => {
+        is 3 -> {
            z = <!UNUSED_VALUE!>34<!>
        }
-        else => <!UNUSED_CHANGED_VALUE!>z--<!>
+        else -> <!UNUSED_CHANGED_VALUE!>z--<!>
    }<!>

    var <!UNUSED_VARIABLE!>iff<!> = <!IMPLICIT_CAST_TO_UNIT_OR_ANY!>if (true) {
@@ -1,13 +1,13 @@
-namespace kt786
+package kt786

 //KT-786 Exception on incomplete code with 'when'
 fun foo() : Int {
    val d = 2
    var z = 0
    when(d) {
-        is 5, is 3 => <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, UNUSED_CHANGED_VALUE!>z++<!>
-        <!ELSE_MISPLACED_IN_WHEN!>else => { <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>z = <!UNUSED_VALUE!>-1000<!><!> }<!>
-        return z => <!UNREACHABLE_CODE!>34<!>
+        is 5, is 3 -> <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, UNUSED_CHANGED_VALUE!>z++<!>
+        <!ELSE_MISPLACED_IN_WHEN!>else -> { <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>z = <!UNUSED_VALUE!>-1000<!><!> }<!>
+        return z -> <!UNREACHABLE_CODE!>34<!>
    }
 }

@@ -15,10 +15,10 @@ fun foo() : Int {
 fun fff(): Int {
    var d = 3
    when(d) {
-        is 4 => 21
-        return 2 => <!UNREACHABLE_CODE!>return 47<!>
-        <!UNREACHABLE_CODE!>bar()<!> => <!UNREACHABLE_CODE!>45<!>
-        <!UNREACHABLE_CODE!>444<!> => <!UNREACHABLE_CODE!>true<!>
+        is 4 -> 21
+        return 2 -> <!UNREACHABLE_CODE!>return 47<!>
+        <!UNREACHABLE_CODE!>bar()<!> -> <!UNREACHABLE_CODE!>45<!>
+        <!UNREACHABLE_CODE!>444<!> -> <!UNREACHABLE_CODE!>true<!>
    }
    return 34
 }
@@ -20,7 +20,7 @@ fun f9(init : A?) {
    a?.<!UNRESOLVED_REFERENCE!>bar<!>()
    a?.foo()
  }
-  if (!(a is B) || a.bar() == ()) {
+  if (!(a is B) || a.bar() == #()) {
      a?.<!UNRESOLVED_REFERENCE!>bar<!>()
  }
  if (!(a is B)) {
@@ -54,24 +54,24 @@ fun f101(a : A?) {

 fun f11(a : A?) {
  when (a) {
-    is B => a.bar()
-    is A => a.foo()
-    is Any => a.foo()
-    is Any? => a.<!UNRESOLVED_REFERENCE!>bar<!>()
-    else => a?.foo()
+    is B -> a.bar()
+    is A -> a.foo()
+    is Any -> a.foo()
+    is Any? -> a.<!UNRESOLVED_REFERENCE!>bar<!>()
+    else -> a?.foo()
  }
 }

 fun f12(a : A?) {
  when (a) {
-    is B => a.bar()
-    is A => a.foo()
-    is Any => a.foo();
-    is Any? => a.<!UNRESOLVED_REFERENCE!>bar<!>()
-    is val c : <!TYPE_MISMATCH_IN_BINDING_PATTERN!>B<!> => c.foo()
-    is val c is C => c.bar()
-    is val c is C => a.bar()
-    else => a?.foo()
+    is B -> a.bar()
+    is A -> a.foo()
+    is Any -> a.foo();
+    is Any? -> a.<!UNRESOLVED_REFERENCE!>bar<!>()
+    is val c : <!TYPE_MISMATCH_IN_BINDING_PATTERN!>B<!> -> c.foo()
+    is val c is C -> c.bar()
+    is val c is C -> a.bar()
+    else -> a?.foo()
  }

  if (a is val b) {
@@ -106,7 +106,7 @@ fun f13(a : A?) {
  }

  a?.foo()
-  if (a is val c is B && a.foo() == () && c.bar() == ()) {
+  if (a is val c is B && a.foo() == #() && c.bar() == #()) {
    c.foo()
    c.bar()
  }
@@ -154,18 +154,18 @@ fun getStringLength(obj : Any) : Char? {

 fun toInt(i: Int?): Int = if (i != null) i else 0
 fun illegalWhenBody(a: Any): Int = when(a) {
-    is Int => a
-    is String => <!TYPE_MISMATCH!>a<!>
+    is Int -> a
+    is String -> <!TYPE_MISMATCH!>a<!>
 }
 fun illegalWhenBlock(a: Any): Int {
    when(a) {
-        is Int => return a
-        is String => return <!TYPE_MISMATCH!>a<!>
+        is Int -> return a
+        is String -> return <!TYPE_MISMATCH!>a<!>
    }
 }
 fun declarations(a: Any?) {
    if (a is String) {
-       val <!UNUSED_VARIABLE!>p4<!>: (Int, String) = (2, a)
+       val <!UNUSED_VARIABLE!>p4<!>: #(Int, String) = #(2, a)
    }
    if (a is String?) {
        if (a != null) {
@@ -186,21 +186,21 @@ fun vars(a: Any?) {
 }
 fun tuples(a: Any?) {
    if (a != null) {
-        val <!UNUSED_VARIABLE!>s<!>: (Any, String) = (a, <!TYPE_MISMATCH!>a<!>)
+        val <!UNUSED_VARIABLE!>s<!>: #(Any, String) = #(a, <!TYPE_MISMATCH!>a<!>)
    }
    if (a is String) {
-        val <!UNUSED_VARIABLE!>s<!>: (Any, String) = (a, a)
+        val <!UNUSED_VARIABLE!>s<!>: #(Any, String) = #(a, a)
    }
-    fun illegalTupleReturnType(): (Any, String) = (<!TYPE_MISMATCH!>a<!>, <!TYPE_MISMATCH!>a<!>)
+    fun illegalTupleReturnType(): #(Any, String) = #(<!TYPE_MISMATCH!>a<!>, <!TYPE_MISMATCH!>a<!>)
    if (a is String) {
-        fun legalTupleReturnType(): (Any, String) = (a, a)
+        fun legalTupleReturnType(): #(Any, String) = #(a, a)
    }
    val <!UNUSED_VARIABLE!>illegalFunctionLiteral<!>: Function0<Int> = <!TYPE_MISMATCH!>{ <!TYPE_MISMATCH!>a<!> }<!>
-    val <!UNUSED_VARIABLE!>illegalReturnValueInFunctionLiteral<!>: Function0<Int> = { (): Int => <!TYPE_MISMATCH!>a<!> }
+    val <!UNUSED_VARIABLE!>illegalReturnValueInFunctionLiteral<!>: Function0<Int> = { (): Int -> <!TYPE_MISMATCH!>a<!> }

    if (a is Int) {
        val <!UNUSED_VARIABLE!>legalFunctionLiteral<!>: Function0<Int> = { a }
-        val <!UNUSED_VARIABLE!>alsoLegalFunctionLiteral<!>: Function0<Int> = { (): Int => a }
+        val <!UNUSED_VARIABLE!>alsoLegalFunctionLiteral<!>: Function0<Int> = { (): Int -> a }
    }
 }
 fun returnFunctionLiteralBlock(a: Any?): Function0<Int> {
@@ -208,12 +208,12 @@ fun returnFunctionLiteralBlock(a: Any?): Function0<Int> {
    else return { 1 }
 }
 fun returnFunctionLiteral(a: Any?): Function0<Int> =
-    if (a is Int) { (): Int => a }
-    else { () => 1 }
+    if (a is Int) { (): Int -> a }
+    else { () -> 1 }

-fun illegalTupleReturnType(a: Any): (Any, String) = (a, <!TYPE_MISMATCH!>a<!>)
+fun illegalTupleReturnType(a: Any): #(Any, String) = #(a, <!TYPE_MISMATCH!>a<!>)

-fun declarationInsidePattern(x: (Any, Any)): String = when(x) { is (val a is String, *) => a; else => "something" }
+fun declarationInsidePattern(x: #(Any, Any)): String = when(x) { is #(val a is String, *) -> a; else -> "something" }

 fun mergeAutocasts(a: Any?) {
  if (a is String || a is Int) {
@@ -224,7 +224,7 @@ fun mergeAutocasts(a: Any?) {
    a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
  }
  when (a) {
-    is String, is Any => a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
+    is String, is Any -> a.<!UNRESOLVED_REFERENCE!>compareTo<!>("")
  }
  if (a is String && a is Any) {
    val <!UNUSED_VARIABLE!>i<!>: Int = a.compareTo("")
@@ -1,4 +1,4 @@
-namespace kt244
+package kt244

 //+JDK

@@ -1,7 +1,7 @@
 // KT-362 Don't allow autocasts on vals that are not internal
-namespace example;
+package example;

-namespace test {
+package test {
    public class Public() {
        public val public : Int? = 1;
        protected val protected : Int? = 1;
@@ -1,7 +1,7 @@
 // One of the two passes is making a scope and turning vals into functions
 // See KT-76

-namespace x
+package x

 val b : Foo = Foo()
 val a1 = b.compareTo(2)
@@ -2,7 +2,7 @@ fun foo(<!UNUSED_PARAMETER!>u<!> : Unit) : Int = 1

 fun test() : Int {
    foo(<!TYPE_MISMATCH!>1<!>)
-    val <!UNUSED_VARIABLE!>a<!> : fun() : Unit = {
+    val <!UNUSED_VARIABLE!>a<!> : () -> Unit = {
        foo(<!TYPE_MISMATCH!>1<!>)
    }
    return 1
@@ -1,6 +1,6 @@
-namespace jet121 {
+package jet121 {
  fun box() : String {
-    val answer = apply("OK") { String.() : Int =>
+    val answer = apply("OK") { String.() : Int ->
      get(0)
      length
    }
@@ -8,7 +8,7 @@ namespace jet121 {
    return if (answer == 2) "OK" else "FAIL"
  }

-  fun apply(arg:String, f : fun String.() : Int) : Int {
+  fun apply(arg:String, f :  String.() -> Int) : Int {
      return arg.f()
  }
 }
@@ -1,8 +1,8 @@
-fun foo1() : fun (Int) : Int = { (x: Int) => x }
+fun foo1() :  (Int) -> Int = { (x: Int) -> x }

 fun foo() {
-  val h : fun (Int) : Int = foo1();
+  val h :  (Int) -> Int = foo1();
  h(1)
-  val m : fun (Int) : Int = {(a : Int) => 1}//foo1()
+  val m :  (Int) -> Int = {(a : Int) -> 1}//foo1()
  m(1)
 }
@@ -1,8 +1,8 @@
 fun set(<!UNUSED_PARAMETER!>key<!> : String, <!UNUSED_PARAMETER!>value<!> : String) {
  val a : String? = ""
  when (a) {
-    "" => a<!UNSAFE_CALL!>.<!>get(0)
-    is String, is Any => a.compareTo("")
-    else => a.toString()
+    "" -> a<!UNSAFE_CALL!>.<!>get(0)
+    is String, is Any -> a.compareTo("")
+    else -> a.toString()
  }
 }
@@ -2,7 +2,7 @@ trait Iterator<out T> {
 fun next() : T
 val hasNext : Boolean

- fun <R> map(transform: fun(element: T) : R) : Iterator<R> =
+ fun <R> map(transform: (element: T) -> R) : Iterator<R> =
    object : Iterator<R> {
      override fun next() : R = transform(<!NO_THIS!>this@map<!>.next())

@@ -1,6 +1,6 @@
 // KT-128 Support passing only the last closure if all the other parameters have default values

-fun div(<!UNUSED_PARAMETER!>c<!> : String = "", <!UNUSED_PARAMETER!>f<!> : fun()) {}
+fun div(<!UNUSED_PARAMETER!>c<!> : String = "", <!UNUSED_PARAMETER!>f<!> : () -> Unit) {}
 fun f() {
    div { // Nothing passed, but could have been...
      // ...
@@ -1,36 +1,36 @@
 //KT-235 Illegal assignment return type
 // +JDK

-namespace kt235
+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 x = 1
       <!EXPECTED_TYPE_MISMATCH!>x = 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<!> = { (): Int ->
       <!ASSIGNMENT_TYPE_MISMATCH!>array[2] = 23<!>
    }
-    val <!UNUSED_VARIABLE!>gi<!> = {(): Int =>
+    val <!UNUSED_VARIABLE!>gi<!> = {(): Int ->
       var x = 1
       <!ASSIGNMENT_TYPE_MISMATCH!>x += 21<!>
    }

    var m: MyNumber = MyNumber()
-    val <!UNUSED_VARIABLE!>a<!> = { (): MyNumber =>
+    val <!UNUSED_VARIABLE!>a<!> = { (): MyNumber ->
        <!UNUSED_CHANGED_VALUE!>m++<!>
    }
 }
@@ -1,7 +1,7 @@
 // KT-26 Import namespaces defined in this file

-namespace foo {
+package foo {
  import bar.* // Must not be an error
 }

-namespace bar {}
+package bar {}
@@ -2,7 +2,7 @@

 import html.* // Must not be an error

-namespace html {
+package html {

  abstract class Factory<T> {
    fun create() : T? = null
@@ -1,6 +1,6 @@
 // KT-302 Report an error when inheriting many implementations of the same member

-namespace kt302
+package kt302

 trait A {
    open fun foo() {}
@@ -1,14 +1,14 @@
 // KT-306 Ambiguity when different this's have same-looking functions

 fun test() {
-    {Foo.() =>
+    {Foo.() ->
        bar()
-        {Barr.() =>
+        {Barr.() ->
            this.bar()
            bar()
        }
    }
-    {Barr.() =>
+    {Barr.() ->
        bar()
    }
 }
@@ -21,7 +21,7 @@ val x = { <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>x<!> }
 val z = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z<!>

 //KT-329 Assertion failure on local function
-fun block(f : fun() : Unit) = f()
+fun block(f : () -> Unit) = f()

 fun bar3() = block{ <!UNRESOLVED_REFERENCE!>foo3<!>() // <-- missing closing curly bracket
 fun foo3() = block{ <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar3()<!> }<!SYNTAX!><!>
@@ -1,26 +1,26 @@
 //KT-352 Function variable declaration type isn't checked inside a function body

-namespace kt352
+package kt352

-val f : fun(Any) : Unit = <!TYPE_MISMATCH!>{ () : Unit => }<!>  //type mismatch
+val f : (Any) -> Unit = <!TYPE_MISMATCH!>{ () : Unit -> }<!>  //type mismatch

 fun foo() {
-    val <!UNUSED_VARIABLE!>f<!> : fun(Any) : Unit = <!TYPE_MISMATCH!>{ () : Unit => }<!>  //!!! no error
+    val <!UNUSED_VARIABLE!>f<!> : (Any) -> Unit = <!TYPE_MISMATCH!>{ () : Unit -> }<!>  //!!! no error
 }

 class A() {
-    val f : fun(Any) : Unit = <!TYPE_MISMATCH!>{ () : Unit => }<!>  //type mismatch
+    val f : (Any) -> Unit = <!TYPE_MISMATCH!>{ () : Unit -> }<!>  //type mismatch
 }

 //more tests
-val g : fun() : Unit = <!TYPE_MISMATCH!>{ (): Int => 42 }<!>
+val g : () -> Unit = <!TYPE_MISMATCH!>{ (): Int -> 42 }<!>

-val h : fun() : Unit = { doSmth() }
+val h : () -> Unit = { doSmth() }

 fun doSmth(): Int = 42
 fun doSmth(<!UNUSED_PARAMETER!>a<!>: String) {}

-val testIt : fun(Any) : Unit = {
+val testIt : (Any) -> Unit = {
    if (it is String) {
        doSmth(it)
    }
@@ -5,7 +5,7 @@ trait A {
 }

 fun foo(a: A) {
-    val <!UNUSED_VARIABLE!>g<!> : fun() : Unit = {
+    val <!UNUSED_VARIABLE!>g<!> : () -> Unit = {
        a.gen()  //it works: Unit is derived
    }

@@ -15,16 +15,16 @@ fun foo(a: A) {
        a.<!TYPE_INFERENCE_FAILED!>gen()<!> // Shouldn't work: no info for inference
    }

-    val <!UNUSED_VARIABLE!>b<!> : fun() : Unit = {
+    val <!UNUSED_VARIABLE!>b<!> : () -> Unit = {
        if (true) {
            a.gen()  // unit can be inferred
        }
        else {
-            ()
+            #()
        }
    }

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

@@ -5,29 +5,29 @@

 import java.util.*

-fun <T> Iterator<T>.foreach(operation: fun(element: T) : Unit)  : Unit = while(hasNext) operation(next())
+fun <T> Iterator<T>.foreach(operation: (element: T) -> Unit)  : Unit = while(hasNext) operation(next())

-fun <T> Iterator<T>.foreach(operation: fun(index: Int, element: T) : Unit) : Unit {
+fun <T> Iterator<T>.foreach(operation: (index: Int, element: T) -> Unit) : Unit {
    var k = 0
    while(hasNext)
        operation(k++, next())
 }

-fun <T> Iterable<T>.foreach(operation: fun(element: T) : Unit) : Unit = iterator() foreach operation
+fun <T> Iterable<T>.foreach(operation: (element: T) -> Unit) : Unit = iterator() foreach operation

-fun <T> Iterable<T>.foreach(operation: fun(index: Int, element: T) : Unit) : Unit = iterator() foreach operation
+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( { () : String -> "OK"} )
 }

-fun <T> generic_invoker(gen : fun () : T) : T {
+fun <T> generic_invoker(gen :  () -> T) : T {
    return gen()
 }

 fun println(message : Int) { System.out?.println(message) }
 fun println(message : Long) { System.out?.println(message) }
-inline fun run<T>(body : fun() : T) : T = body()
+inline fun run<T>(body : () -> T) : T = body()

 fun main(args : Array<String>) {

@@ -1,7 +1,7 @@
 // KT-398 Internal error when property initializes with function

 class X<T>() {
-    val check = { (a : Any) => a is T }
+    val check = { (a : Any) -> a is 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 T }
+    return { (a : Any) -> a is T }
 }

 fun box() : String {
@@ -1,8 +1,8 @@
-namespace kt402
+package kt402

-fun getTypeChecker() : fun(Any):Boolean {
-  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{ (a : Any) => a is <!UNRESOLVED_REFERENCE!>T<!> }<!> // reports unsupported
+fun getTypeChecker() : (Any)->Boolean {
+  <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{ (a : Any) -> a is <!UNRESOLVED_REFERENCE!>T<!> }<!> // reports unsupported
 }
-fun f() : fun(Any) : Boolean {
-  return { (a : Any) => a is String }
+fun f() : (Any) -> Boolean {
+  return { (a : Any) -> a is String }
 }
@@ -1,6 +1,6 @@
 // KT-41 Make functions with errors in returning statement return ERROR type and not Nothing

-namespace kt41
+package kt41

 fun aaa() =
  6 <!UNRESOLVED_REFERENCE!>foo<!> 1
@@ -1,6 +1,6 @@
 //kt-411 Wrong type expected when returning from a function literal

-namespace kt411
+package kt411

 fun f() {
    invoker(
@@ -9,17 +9,17 @@ fun f() {
    }
    )
 }
-fun invoker(<!UNUSED_PARAMETER!>gen<!> : fun() : Int) : Int  = 0
+fun invoker(<!UNUSED_PARAMETER!>gen<!> : () -> Int) : Int  = 0

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

 fun t2() : String {
-    val <!UNUSED_VARIABLE!>g<!> : fun(): Int = @{
+    val <!UNUSED_VARIABLE!>g<!> : ()-> Int = @{
        if (true) {
            return@ 1
        }
@@ -41,7 +41,7 @@ fun t3() : String {
    }
    )
    invoker(
-    @{ (): Int =>
+    @{ (): Int ->
        return@ 1
    }
    )
@@ -54,10 +54,10 @@ fun t3() : String {
 }

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

@@ -1,6 +1,6 @@
 // KT-439 Support labeled function literals in call arguments

-inline fun run1<T>(body : fun() : T) : T = body()
+inline fun run1<T>(body : () -> T) : T = body()

 fun main1(<!UNUSED_PARAMETER!>args<!> : Array<String>) {
    run1 @l{ 1 } // should not be an error
@@ -1,12 +1,12 @@
 // KT-442 Type inference fails on with()

-fun <T> funny(f : fun() : T) : T = f()
+fun <T> funny(f : () -> T) : T = f()

 fun testFunny() {
    val <!UNUSED_VARIABLE!>a<!> : Int = funny {1}
 }

-fun <T> funny2(<!UNUSED_PARAMETER!>f<!> : fun(t : T) : T) : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>
+fun <T> funny2(<!UNUSED_PARAMETER!>f<!> : (t : T) -> T) : T <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>{}<!>

 fun testFunny2() {
    val <!UNUSED_VARIABLE!>a<!> : Int = funny2 {it}
@@ -16,11 +16,11 @@ fun box() : String {
    return generic_invoker { it }
 }

-fun <T> generic_invoker(gen : fun (String) : T) : T {
+fun <T> generic_invoker(gen :  (String) -> T) : T {
    return gen("")
 }

-fun <T> T.with(f : fun T.()) {
+fun <T> T.with(f :  T.() -> Unit) {
    f()
 }

@@ -1,6 +1,6 @@
 //KT-455 Do not repeat errors in definite assignment checks

-namespace kt455
+package kt455

 fun foo() {
    val a: Int
@@ -1,6 +1,6 @@
 //KT-456 No check for obligatory return in getters

-namespace kt456
+package kt456

 class A() {
    val i: Int
@@ -1,6 +1,6 @@
 // +JDK

-namespace kt469
+package kt469

 //KT-512 plusAssign() : Unit does not work properly
 import java.util.*
@@ -1,7 +1,7 @@
 // KT-524 sure() returns T
 // +JDK

-namespace StringBuilder
+package StringBuilder

 import java.lang.StringBuilder

@@ -1,7 +1,7 @@
 // http://youtrack.jetbrains.net/issue/KT-526
 // KT-526 Unresolved reference for inner static class

-namespace demo
+package demo

 class Foo {
    class object {
@@ -1,9 +1,9 @@
 //KT-549 type inference failed
 // +JDK

-namespace demo
+package demo

-  fun filter<T>(list : Array<T>, filter : fun (T) : Boolean) : java.util.List<T> {
+  fun filter<T>(list : Array<T>, filter :  (T) -> Boolean) : java.util.List<T> {
    val answer = java.util.ArrayList<T>();
    for (l in list) {
      if (filter(l)) answer.add(l)
@@ -1,3 +1,3 @@
 //KT-571 Type inference failed
-fun <T, R> let(t : T, body : fun(T) : R) = body(t)
+fun <T, R> let(t : T, body : (T) -> R) = body(t)
 private fun double(d : Int) : Int = let(d * 2) {it / 10 + it * 2 % 10}
@@ -1,6 +1,6 @@
 // KT-575 Cannot ++ a class object member

-namespace kt575
+package kt575

 class Creature() {
    class object {
@@ -1,11 +1,11 @@
 //KT-58 Allow finally around definite returns
 // +JDK

-namespace kt58
+package kt58

 import java.util.concurrent.locks.Lock

-fun lock<T>(lock : Lock, body : fun () : T) : T {
+fun lock<T>(lock : Lock, body :  () -> T) : T {
    lock.lock()
    try {
        return body()
@@ -1,7 +1,7 @@
 //KT-580 Type inference failed
 // +JDK

-namespace whats.the.difference
+package whats.the.difference

 import java.util.*

@@ -11,7 +11,7 @@ trait ChannelPipelineFactory{
    fun getPipeline() : ChannelPipeline
 }

-class StandardPipelineFactory(val config: fun ChannelPipeline.():Unit) : ChannelPipelineFactory {
+class StandardPipelineFactory(val config:  ChannelPipeline.()->Unit) : ChannelPipelineFactory {
    override fun getPipeline() : ChannelPipeline {
        val pipeline = DefaultChannelPipeline()
        pipeline.config ()
@@ -1,4 +1,4 @@
-namespace lol
+package lol

 class B() {
    fun plusAssign(<!UNUSED_PARAMETER!>other<!> : B) : String {
@@ -1,6 +1,6 @@
 //KT-629 Assignments are parsed as expressions.

-namespace kt629
+package kt629

 class A() {
    var p = "yeah"
@@ -6,7 +6,7 @@ open class B() : A() {


 class C() {
-  fun a<T>(x: fun(T):T, y: T): T {
+  fun a<T>(x: (T)->T, y: T): T {
    return x(x(y))
  }

@@ -1,2 +1,2 @@
 // KT-691 Allow to create nested namespaces with dot delimiter
-namespace foo.bar.buz
+package foo.bar.buz
@@ -2,5 +2,5 @@
 // +JDK
 class List<T>(val head: T, val tail: List<T>? = null)

-fun <T, Q> List<T>.map(f: fun(T): Q): List<T>? = tail.sure<List<T>>().map(f)
+fun <T, Q> List<T>.map(f: (T)-> Q): List<T>? = tail.sure<List<T>>().map(f)
 fun foo<T>(t : T) : T = foo(t)
@@ -1,7 +1,7 @@
 // KT-860 ConcurrentModificationException in frontend
 // +JDK

-namespace std.util
+package std.util

 import java.util.*

@@ -1,6 +1,6 @@
 // +JDK

-namespace kt_250_617_10
+package kt_250_617_10

 import java.util.ArrayList
 import java.util.HashMap
@@ -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
-    { (): Unit => var <!NAME_SHADOWING!>i<!> = 18 }
+    { (): Unit -> var <!NAME_SHADOWING!>i<!> = 18 }
    return i
 }
@@ -1,5 +1,5 @@
 fun ff(): Int {
    var i = 1
-    { (i: Int) => i }
+    { (i: Int) -> i }
    return i
 }