More override control.

Renderers in errors.
Constructor parameters are not properties unless otherwise specified

idea/testData/checker/Constructors.jet

@@ -33,7 +33,7 @@ class Foo() : <error>WithPC0</error>, <error>this</error>() {
 
 }
 
-class WithCPI_Dup(<error>x</error> : Int) {
+class WithCPI_Dup(x : Int) {
   var <error>x</error> : Int
 }
 

idea/testData/checker/infos/PropertiesWithBackingFields.jet

@@ -44,7 +44,7 @@
 
 <info>open</info> class Super(i : Int)
 
-class TestPCParameters(w : Int, <info>x</info> : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
+class TestPCParameters(w : Int, x : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
 
   val <info>xx</info> = w
 
@@ -52,6 +52,6 @@ class TestPCParameters(w : Int, <info>x</info> : Int, val <info>y</info> : Int,
     w + 1
   }
 
-  fun foo() = x
+  fun foo() = <error>x</error>
 
 }

idea/testData/checkerWithErrorTypes/full/Constructors.jet

@@ -1,4 +1,3 @@
-
 open class NoC
 class NoC1 : NoC
 
@@ -33,8 +32,8 @@ class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!MANY_C
 
 }
 
-class WithCPI_Dup(<!REDECLARATION, REDECLARATION!>x<!> : Int) {
-  var <!REDECLARATION, REDECLARATION, MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
+class WithCPI_Dup(x : Int) {
+  var <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>x<!> : Int
 }
 
 class WithCPI(x : Int) {

idea/testData/checkerWithErrorTypes/full/CovariantOverrideType.jet

@@ -0,0 +1,26 @@
+trait A {
+    fun foo() : Int = 1
+    fun foo1() : Int = 1
+    val a : Int
+    val a1 : Int
+    val <T> g : Iterator<T>
+
+    fun <T> g() : T
+    fun <T> g1() : T
+}
+
+abstract class B() : A {
+    override fun <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>foo<!>() {
+    }
+    override fun foo() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Unit<!> {
+    }
+
+    override val a : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Double<!> = 1.dbl
+    override val <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>a1<!> = 1.dbl
+
+    abstract override fun <X> g() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Int<!>
+    abstract override fun <X> g1() : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>java.util.List<X><!>
+
+    abstract override val <X> g : <!RETURN_TYPE_MISMATCH_ON_OVERRIDE!>Iterator<Int><!>
+}
+

idea/testData/checkerWithErrorTypes/full/infos/PropertiesWithBackingFields.jet

@@ -52,6 +52,6 @@ class TestPCParameters(w : Int, x : Int, val y : Int, var z : Int) : Super(w) {
     w + 1
   }
 
-  fun foo() = x
+  fun foo() = <!UNRESOLVED_REFERENCE!>x<!>
 
 }

idea/testData/checkerWithErrorTypes/quick/Override.jet

@@ -16,17 +16,17 @@ namespace normal {
 
     class MyChildClass : MyClass {}
 
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalClass<!> : MyTrait, MyAbstractClass {}
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass<!> : MyTrait, MyAbstractClass {}
 
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalClass2<!> : MyTrait, MyAbstractClass {
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!> : MyTrait, MyAbstractClass {
         override fun foo() {}
     }
 
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalClass3<!> : MyTrait, MyAbstractClass {
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass3<!> : MyTrait, MyAbstractClass {
         override fun bar() {}
     }
 
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalClass4<!> : MyTrait, MyAbstractClass {
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass4<!> : MyTrait, MyAbstractClass {
         fun <!VIRTUAL_MEMBER_HIDDEN!>foo<!>() {}
         <!NOTHING_TO_OVERRIDE!>override<!> fun other() {}
     }
@@ -63,13 +63,13 @@ namespace generics {
         override fun bar(s: String) = s
     }
 
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T> {}
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R> : MyTrait<T>, MyAbstractClass<R> {
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T> {}
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R> : MyTrait<T>, MyAbstractClass<R> {
         <!NOTHING_TO_OVERRIDE!>override<!> fun foo(r: R) = r
     }
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String> {}
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String> {}
 
-    class <!ABSTRACT_METHOD_NOT_IMPLEMENTED!>MyIllegalClass2<!><T> : MyTrait<Int>, MyAbstractClass<Int> {
+    class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!><T> : MyTrait<Int>, MyAbstractClass<Int> {
         fun foo(t: T) = t
         fun bar(t: T) = t
     }

idea/testData/codegen/classes/inheritance.jet

@@ -5,7 +5,7 @@ trait Y {
     abstract val y : Int
 }
 
-class YImpl(val y : Int) : Y {}
+class YImpl(override val y : Int) : Y {}
 
 class Point(x : Int, yy : Int) : X(x) , Y {
     override val y : Int = yy