Annotator test data fixed

idea/testData/checker/Abstract.jet

@@ -118,7 +118,7 @@ enum class MyEnum() {
 
 abstract enum class MyAbstractEnum() {}
 
-package MyNamespace {
+//package MyNamespace {
     //properties
     val <error>a</error>: Int
     val a1: Int = 1
@@ -145,7 +145,7 @@ package MyNamespace {
     fun g() {}
     <error>abstract</error> fun h()
     <error>abstract</error> fun j() {}
-}
+//}
 
 //creating an instance
 abstract class B1(

idea/testData/checker/Bounds.jet

@@ -1,20 +1,3 @@
-package boundsWithSubstitutors {
-    open class A<T>
-    class B<X : A<X>>()
-
-    class C : A<C>
-
-    val a = B<C>()
-    val a1 = B<<error>Int</error>>()
-
-    class X<A, B : A>()
-
-    val b = X<Any, X<A<C>, C>>
-    val b0 = X<Any, <error>Any?</error>>
-    val b1 = X<Any, X<A<C>, <error>String</error>>>
-
-}
-
   open class A {}
   open class B<T : A>()
 

idea/testData/checker/BoundsWithSubstitutors.jet

@@ -0,0 +1,13 @@
+    open class A<T>
+    class B<X : A<X>>()
+
+    class C : A<C>
+
+    val a = B<C>()
+    val a1 = B<<error>Int</error>>()
+
+    class X<A, B : A>()
+
+    val b = X<Any, X<A<C>, C>>
+    val b0 = X<Any, <error>Any?</error>>
+    val b1 = X<Any, X<A<C>, <error>String</error>>>

idea/testData/checker/Builders.jet

@@ -1,6 +1,6 @@
-import java.util.*
+package html
 
-package html {
+import java.util.*
 
   abstract class Factory<T> {
     abstract fun create() : T
@@ -83,12 +83,6 @@ package html {
     return html
   }
 
-}
-
-package foo {
-
-import html.*
-
 fun result(args : Array<String>) =
   html {
     head {
@@ -118,4 +112,3 @@ fun result(args : Array<String>) =
       }
     }
   }
-}

idea/testData/checker/ExtensionFunctions.jet

@@ -1,5 +1,3 @@
-// FILE: b.kt
-
 fun Int?.optint() : Unit {}
 val Int?.optval : Unit = #()
 
@@ -40,7 +38,7 @@ val <T> T.<error>foo</error> : T
 fun Int.foo() = this
 
 // FILE: b.kt
-package null_safety
+//package null_safety
 
         fun parse(<warning>cmd</warning>: String): Command? { return null  }
         class Command() {

idea/testData/checker/GenericArgumentConsistency.jet

@@ -13,30 +13,30 @@ trait BB1 : BA1<Int> {}
 trait BB2 : <error>BA1<Any>, BB1</error> {}
 
 
-package x {
+//package x {
-    trait AA1<out T> {}
+    trait xAA1<out T> {}
-    trait AB1 : AA1<Int> {}
+    trait xAB1 : xAA1<Int> {}
-    trait AB3 : AA1<Comparable<Int>> {}
+    trait xAB3 : xAA1<Comparable<Int>> {}
-    trait AB2 : AA1<Number>, AB1, AB3 {}
+    trait xAB2 : xAA1<Number>, xAB1, xAB3 {}
-}
+//}
 
-package x2 {
+//package x2 {
-    trait AA1<out T> {}
+    trait x2AA1<out T> {}
-    trait AB1 : AA1<Any> {}
+    trait x2AB1 : x2AA1<Any> {}
-    trait AB3 : AA1<Comparable<Int>> {}
+    trait x2AB3 : x2AA1<Comparable<Int>> {}
-    trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
+    trait x2AB2 : <error>x2AA1<Number>, x2AB1, x2AB3</error> {}
-}
+//}
 
-package x3 {
+//package x3 {
-    trait AA1<in T> {}
+    trait x3AA1<in T> {}
-    trait AB1 : AA1<Any> {}
+    trait x3AB1 : x3AA1<Any> {}
-    trait AB3 : AA1<Comparable<Int>> {}
+    trait x3AB3 : x3AA1<Comparable<Int>> {}
-    trait AB2 : AA1<Number>, AB1, AB3 {}
+    trait x3AB2 : x3AA1<Number>, x3AB1, x3AB3 {}
-}
+//}
 
-package sx2 {
+//package sx2 {
-    trait AA1<in T> {}
+    trait sx2AA1<in T> {}
-    trait AB1 : AA1<Int> {}
+    trait sx2AB1 : sx2AA1<Int> {}
-    trait AB3 : AA1<Comparable<Int>> {}
+    trait sx2AB3 : sx2AA1<Comparable<Int>> {}
-    trait AB2 : <error>AA1<Number>, AB1, AB3</error> {}
+    trait sx2AB2 : <error>sx2AA1<Number>, sx2AB1, sx2AB3</error> {}
-}
+//}

idea/testData/checker/LocalObjects.jet

@@ -0,0 +1,21 @@
+  object A {
+    val x : Int = 0
+  }
+
+  open class Foo {
+    fun foo() : Int = 1
+  }
+
+  fun test() {
+    A.x
+    val b = object : Foo {
+    }
+    b.foo()
+
+    object B {
+      fun foo() {}
+    }
+    B.foo()
+  }
+
+  val bb = <error>B</error>.foo()

idea/testData/checker/NamespaceAsExpression.jet

@@ -1,8 +1,4 @@
 package root
 
-package a {
+val x = <error>root</error>
-
-}
-
-val x = <error>a</error>
 val y2 = <error>package</error>

idea/testData/checker/NamespaceQualified.jet

@@ -1,29 +1,8 @@
-package foobar
+package a
 
-package a {
     import java.*
-
-    val a : util.List<Int>? = null
-    val a1 : <error>List</error><Int>? = null
-
-}
-
-abstract class Foo<T>() {
-    abstract val x : T<Int>
-}
-
-package a {
     import java.util.*
 
-    val b : List<Int>? = a
-    val b1 : <error>util</error>.List<Int>? = a
-}
-
-val x1 = a.a
-
-val y1 = a.b
-
-
 /////////////////////////////////////////////////////////////////////////
 
 fun done<O>(result : O) : Iteratee<Any?, O> = StrangeIterateeImpl<Any?, O>(result)
@@ -44,7 +23,7 @@ class StrangeIterateeImpl<in I, out O>(val obj: O) : Iteratee<I, O> {
 
 abstract class Sum() : Iteratee<Int, Int> {
   override fun process(item : Int) : Iteratee<Int, Int> {
-    return foobar.done<Int>(item);
+    return a.done<Int>(item);
   }
   abstract override val isDone : Boolean
   abstract override val result : Int

idea/testData/checker/NestedObjects.jet

@@ -0,0 +1,28 @@
+package nestedObjects
+  object A {
+    val b = B
+    val d = A.B.A
+
+    object B {
+      val a = A
+      val e = B.A
+
+      object A {
+        val a = A
+        val b = B
+        val x = nestedObjects.A.B.A
+        val y = this<error>@A</error>
+      }
+    }
+
+  }
+  object B {
+    val b = B
+    val c = A.B
+  }
+
+  val a = A
+  val b = B
+  val c = A.B
+  val d = A.B.A
+  val e = B.<error>A</error>.B

idea/testData/checker/Objects.jet

@@ -1,4 +1,4 @@
-package toplevelObjectDeclarations {
+package toplevelObjectDeclarations
   open class Foo(y : Int) {
     open fun foo() : Int = 1
   }
@@ -25,59 +25,4 @@ package toplevelObjectDeclarations {
     override fun foo() : Int = 1
   }
 
-  val z = y.foo()
+  val z = y.foo()
-}
-
-package nestedObejcts {
-  object A {
-    val b = B
-    val d = A.B.A
-
-    object B {
-      val a = A
-      val e = B.A
-
-      object A {
-        val a = A
-        val b = B
-        val x = nestedObejcts.A.B.A
-        val y = this<error>@A</error>
-      }
-    }
-
-  }
-  object B {
-    val b = B
-    val c = A.B
-  }
-
-  val a = A
-  val b = B
-  val c = A.B
-  val d = A.B.A
-  val e = B.<error>A</error>.B
-}
-
-package localObjects {
-  object A {
-    val x : Int = 0
-  }
-
-  open class Foo {
-    fun foo() : Int = 1
-  }
-
-  fun test() {
-    A.x
-    val b = object : Foo {
-    }
-    b.foo()
-
-    object B {
-      fun foo() {}
-    }
-    B.foo()
-  }
-
-  val bb = <error>B</error>.foo()
-}

idea/testData/checker/Override.jet

@@ -1,6 +1,5 @@
 package override
 
-package normal {
     trait MyTrait {
         fun foo()
     }
@@ -35,42 +34,3 @@ package normal {
         fun <error>foo</error>() {}
         override fun bar() {}
     }
-}
-
-package generics {
-    trait MyTrait<T> {
-        fun foo(t: T) : T
-    }
-
-    abstract class MyAbstractClass<T> {
-        abstract fun bar(t: T) : T
-    }
-
-    open class MyGenericClass<T> : MyTrait<T>, MyAbstractClass<T> {
-        override fun foo(t: T) = t
-        override fun bar(t: T) = t
-    }
-
-    class MyChildClass : MyGenericClass<Int> {}
-    class MyChildClass1<T> : MyGenericClass<T> {}
-    class MyChildClass2<T> : MyGenericClass<T> {
-        fun <error>foo</error>(t: T) = t
-        override fun bar(t: T) = t
-    }
-
-    open class MyClass : MyTrait<Int>, MyAbstractClass<String> {
-        override fun foo(i: Int) = i
-        override fun bar(s: String) = s
-    }
-
-    class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T> {}
-    class <error>MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R> {
-        <error>override</error> fun foo(r: R) = r
-    }
-    class <error>MyIllegalClass1</error> : MyTrait<Int>, MyAbstractClass<String> {}
-
-    class <error>MyIllegalClass2</error><T> : MyTrait<Int>, MyAbstractClass<Int> {
-        fun foo(t: T) = t
-        fun bar(t: T) = t
-    }
-}

idea/testData/checker/OverridesAndGenerics.jet

@@ -0,0 +1,35 @@
+    trait MyTrait<T> {
+        fun foo(t: T) : T
+    }
+
+    abstract class MyAbstractClass<T> {
+        abstract fun bar(t: T) : T
+    }
+
+    open class MyGenericClass<T> : MyTrait<T>, MyAbstractClass<T> {
+        override fun foo(t: T) = t
+        override fun bar(t: T) = t
+    }
+
+    class MyChildClass : MyGenericClass<Int> {}
+    class MyChildClass1<T> : MyGenericClass<T> {}
+    class MyChildClass2<T> : MyGenericClass<T> {
+        fun <error>foo</error>(t: T) = t
+        override fun bar(t: T) = t
+    }
+
+    open class MyClass : MyTrait<Int>, MyAbstractClass<String> {
+        override fun foo(i: Int) = i
+        override fun bar(s: String) = s
+    }
+
+    class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T> {}
+    class <error>MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R> {
+        <error>override</error> fun foo(r: R) = r
+    }
+    class <error>MyIllegalClass1</error> : MyTrait<Int>, MyAbstractClass<String> {}
+
+    class <error>MyIllegalClass2</error><T> : MyTrait<Int>, MyAbstractClass<Int> {
+        fun foo(t: T) = t
+        fun bar(t: T) = t
+    }

idea/testData/checker/QualifiedThis.jet

@@ -21,21 +21,3 @@ fun foo1() : Unit {
   this<error>@a</error>
 }
 
-package closures {
-    class A(val a:Int) {
-
-      class B() {
-        val x = this@B : B
-        val y = this@A : A
-        val z = this : B
-        val Int.xx = this : Int
-        fun Char.xx() : Any {
-          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> + this@xx : Char}
-          return (@a{Double.() -> this@a : Double + this@xx : Char})
-        }
-      }
-    }
-}

idea/testData/checker/QualifiedThisInClosures.jet

@@ -0,0 +1,16 @@
+    class A(val a:Int) {
+
+      class B() {
+        val x = this@B : B
+        val y = this@A : A
+        val z = this : B
+        val Int.xx = this : Int
+        fun Char.xx() : Any {
+          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> + this@xx : Char}
+          return (@a{Double.() -> this@a : Double + this@xx : Char})
+        }
+      }
+    }

idea/testData/checker/RecursiveTypeInference.jet

@@ -1,42 +1,42 @@
-package a {
+//package a {
-    val foo = bar()
+    val afoo = abar()
 
-    fun bar() = <error descr="[TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM] Type checking has run into a recursive problem">foo</error>
+    fun abar() = <error descr="[TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM] Type checking has run into a recursive problem">afoo</error>
-}
+//}
 
-package b {
+//package b {
-    fun foo() = bar()
+    fun bfoo() = bbar()
 
-    fun bar() = <error descr="[TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM] Type checking has run into a recursive problem">foo()</error>
+    fun bbar() = <error descr="[TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM] Type checking has run into a recursive problem">bfoo()</error>
-}
+//}
 
-package c {
+//package c {
-    fun bazz() = bar()
+    fun cbazz() = cbar()
 
-    fun foo() = <error descr="[TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM] Type checking has run into a recursive problem">bazz()</error>
+    fun cfoo() = <error descr="[TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM] Type checking has run into a recursive problem">cbazz()</error>
 
-    fun bar() = foo()
+    fun cbar() = cfoo()
-}
+//}
 
-package ok {
+//package ok {
+//
+//    package a {
+        val okafoo = okabar()
 
-    package a {
+        fun okabar() : Int = okafoo
-        val foo = bar()
+//    }
+//
+//    package b {
+        fun okbfoo() : Int = okbbar()
 
-        fun bar() : Int = foo
+        fun okbbar() = okbfoo()
-    }
+//    }
+//
+//    package c {
+        fun okcbazz() = okcbar()
 
-    package b {
+        fun okcfoo() : Int = okcbazz()
-        fun foo() : Int = bar()
 
-        fun bar() = foo()
+        fun okcbar() = okcfoo()
-    }
+//    }
-
+//}
-    package c {
-        fun bazz() = bar()
-
-        fun foo() : Int = bazz()
-
-        fun bar() = foo()
-    }
-}

idea/testData/checker/Redeclarations.jet

@@ -1,16 +1,12 @@
-package redeclarations {
+//package redeclarations {
   object <error>A</error> {
     val x : Int = 0
 
     val A = 1
   }
 
-  package <error>A</error> {
-    class A {}
-  }
-
   class <error>A</error> {}
 
   val <error>A</error> = 1
 
-}
+//}

idea/testData/checker/ResolveToJava.jet

@@ -43,10 +43,6 @@ fun test(<warning>l</warning> : java.util.List<Int>) {
   c : java.lang.Comparable<Int>?
 
 //  Collections.sort<Integer>(ArrayList<Integer>())
-  xxx.<error>Class</error>()
 }
 
 
-package xxx {
-  import java.lang.Class;
-}

idea/testData/checker/regression/Jet121.jet

@@ -1,4 +1,4 @@
-package jet121 {
+package jet121
   fun box() : String {
     val answer = apply("OK") { String.() : Int ->
       get(0)
@@ -10,5 +10,4 @@ package jet121 {
 
   fun apply(arg:String, f :  String.() -> Int) : Int {
       return arg.f()
-  }
+  }
-}