'override' checks changed; tests added

idea/testData/checker/Override.jet

@@ -0,0 +1,76 @@
+namespace override
+
+namespace normal {
+    trait MyTrait {
+        fun foo()
+    }
+
+    abstract class MyAbstractClass {
+        abstract fun bar()
+    }
+
+    open class MyClass : MyTrait, MyAbstractClass {
+        override fun foo() {}
+        override fun bar() {}
+    }
+
+    class MyChildClass : MyClass {}
+
+    class <error>MyIllegalClass</error> : MyTrait, MyAbstractClass {}
+
+    class <error>MyIllegalClass2</error> : MyTrait, MyAbstractClass {
+        override fun foo() {}
+    }
+
+    class <error>MyIllegalClass3</error> : MyTrait, MyAbstractClass {
+        override fun bar() {}
+    }
+
+    class <error>MyIllegalClass4</error> : MyTrait, MyAbstractClass {
+        fun <error>foo</error>() {}
+        <error>override</error> fun other() {}
+    }
+
+    class MyChildClass1 : MyClass {
+        fun <error>foo</error>() {}
+        override fun bar() {}
+    }
+}
+
+namespace 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
+    }
+}