diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
index 7eb00091660..54c3c4faa90 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java
@@ -166,7 +166,7 @@ public interface Errors {
     DiagnosticFactory0<JetDelegatorByExpressionSpecifier> DELEGATION_IN_TRAIT = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory2<PsiNameIdentifierOwner, ClassDescriptor, ClassDescriptor> UNMET_TRAIT_REQUIREMENT =
-            DiagnosticFactory2.create(ERROR, PositioningStrategies.NAMED_ELEMENT);
+            DiagnosticFactory2.create(ERROR, PositioningStrategies.NAME_IDENTIFIER);
 
     // Enum-specific
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
index 3c9053bb740..8980b661c07 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/PositioningStrategies.java
@@ -23,6 +23,7 @@ import com.intellij.lang.ASTNode;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiNameIdentifierOwner;
+import com.intellij.psi.tree.TokenSet;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetNodeTypes;
@@ -97,6 +98,20 @@ public class PositioningStrategies {
         public List<TextRange> mark(@NotNull PsiNameIdentifierOwner element) {
             PsiElement nameIdentifier = element.getNameIdentifier();
             if (nameIdentifier != null) {
+                if (element instanceof JetClassOrObject) {
+                    ASTNode startNode = null;
+                    if (((JetClassOrObject) element).hasModifier(JetTokens.ENUM_KEYWORD)) {
+                        //noinspection ConstantConditions
+                        startNode = ((JetClassOrObject) element).getModifierList().getModifier(JetTokens.ENUM_KEYWORD).getNode();
+                    }
+                    if (startNode == null) {
+                        startNode = element.getNode().findChildByType(TokenSet.create(JetTokens.CLASS_KEYWORD, JetTokens.OBJECT_KEYWORD));
+                    }
+                    if (startNode == null) {
+                        startNode = element.getNode();
+                    }
+                    return markRange(startNode.getPsi(), nameIdentifier);
+                }
                 return markElement(nameIdentifier);
             }
             if (element instanceof JetObjectDeclaration) {
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt b/compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt
index 3a9ec35ca78..3106a880fc5 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt
@@ -12,9 +12,9 @@ fun foo() {
     x.foo()
 }
 
-object <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Rr<!> : SomeTrait {}
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object Rr<!> : SomeTrait {}
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>C<!> : SomeTrait {}
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!> : SomeTrait {}
 
 fun foo2() {
     val <!UNUSED_VARIABLE!>r<!> = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : Runnable {} //no error
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/kt559.kt b/compiler/testData/diagnostics/tests/declarationChecks/kt559.kt
index 95c0c20dfb2..029a2d5e330 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/kt559.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/kt559.kt
@@ -14,13 +14,13 @@ abstract class D(): A() {
     override val i : Int = 34
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>C<!>() : D() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!>() : D() {
     fun test() {
         super.i
     }
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>B<!>() : A() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
     override fun foo(): Int {
         super.<!ABSTRACT_SUPER_CALL!>i<!>
 
diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt b/compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt
index 982b5be9039..3ef6662da6f 100644
--- a/compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt
+++ b/compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt
@@ -5,11 +5,11 @@ trait T {
     val v : Int
 }
 
-open class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Br<!>(t : T) : T {
+open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Br<!>(t : T) : T {
 
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Br3<!>(t : T) : Br(t) {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Br3<!>(t : T) : Br(t) {
 
 }
 
@@ -25,7 +25,7 @@ trait G<T> {
     fun foo(t : T) : T
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>GC<!>() : G<Int> {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class GC<!>() : G<Int> {
 
 }
 
diff --git a/compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt b/compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt
index df89ca1d253..5dc08ebb127 100644
--- a/compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt
+++ b/compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt
@@ -10,9 +10,9 @@ trait Three {
     public fun foo(): String
 }
 
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test123<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Two by v2, Three by v3 { }
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test132<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Three by v3, Two by v2 { }
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test312<!>(val v1: One, val v2: Two, val v3: Three) : Three by v3, One by v1, Two by v2 { }
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test321<!>(val v1: One, val v2: Two, val v3: Three) : Three by v3, Two by v2, One by v1 { }
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test231<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, Three by v3, One by v1 { }
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test213<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, One by v1, Three by v3 { }
\ No newline at end of file
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test123<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Two by v2, Three by v3 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test132<!>(val v1: One, val v2: Two, val v3: Three) : One by v1, Three by v3, Two by v2 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test312<!>(val v1: One, val v2: Two, val v3: Three) : Three by v3, One by v1, Two by v2 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test321<!>(val v1: One, val v2: Two, val v3: Three) : Three by v3, Two by v2, One by v1 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test231<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, Three by v3, One by v1 { }
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test213<!>(val v1: One, val v2: Two, val v3: Three) : Two by v2, One by v1, Three by v3 { }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt b/compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt
index 22557012035..bb5209747a9 100644
--- a/compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt
+++ b/compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt
@@ -14,6 +14,6 @@ trait TwoImpl : Two {
   public override fun foo() = 2
 }
 
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test1<!>() : TwoImpl, OneImpl {}
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test1<!>() : TwoImpl, OneImpl {}
 class Test2(a : One) : One by a, Two {}
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>Test3<!>(a : One, b : Two) : Two by b, One by a {}
\ No newline at end of file
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test3<!>(a : One, b : Two) : Two by b, One by a {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt
index 4c2c268fa6f..01d7a092bca 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt
@@ -1,3 +1,3 @@
-object <!CONFLICTING_JVM_DECLARATIONS!>O<!> {
+<!CONFLICTING_JVM_DECLARATIONS!>object O<!> {
     <!CONFLICTING_JVM_DECLARATIONS!>val `INSTANCE$`: O<!> = null!!
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt b/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt
index 70be742354a..17f11e03593 100644
--- a/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt
+++ b/compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt
@@ -1,6 +1,6 @@
 class A {
     inner class B {
-        enum class <!NESTED_CLASS_NOT_ALLOWED!>E<!> {
+        <!NESTED_CLASS_NOT_ALLOWED!>enum class E<!> {
             ENTRY
         }
     }
diff --git a/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt b/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt
index 491f81b6359..68c6904ca23 100644
--- a/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt
+++ b/compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt
@@ -4,6 +4,6 @@ class A {
     }
     
     inner class B {
-        enum class <!NESTED_CLASS_NOT_ALLOWED!>E<!> { ENTRY }
+        <!NESTED_CLASS_NOT_ALLOWED!>enum class E<!> { ENTRY }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt
index d95c892e593..c8f114d1c62 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt
@@ -1,4 +1,4 @@
 package typeReferenceError
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Pair<!><<!SYNTAX!><!>:(val c: <!SYNTAX!><!SYNTAX!><!>fun<!><!SYNTAX!><!> <!UNRESOLVED_REFERENCE!>main<!>()
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Pair<!><<!SYNTAX!><!>:(val c: <!SYNTAX!><!SYNTAX!><!>fun<!><!SYNTAX!><!> <!UNRESOLVED_REFERENCE!>main<!>()
 
diff --git a/compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed.kt b/compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed.kt
index cf84e336468..a5865d6383f 100644
--- a/compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed.kt
+++ b/compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed.kt
@@ -1,18 +1,18 @@
 class A {
     inner class B {
-        class <!NESTED_CLASS_NOT_ALLOWED!>C<!>
+        <!NESTED_CLASS_NOT_ALLOWED!>class C<!>
     }
     
     fun foo() {
         class B {
-            class <!NESTED_CLASS_NOT_ALLOWED!>C<!>
+            <!NESTED_CLASS_NOT_ALLOWED!>class C<!>
         }
     }
 }
 
 fun foo() {
     class B {
-        class <!NESTED_CLASS_NOT_ALLOWED!>C<!>
+        <!NESTED_CLASS_NOT_ALLOWED!>class C<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt b/compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt
index 828620f7fbf..3e66d7f5c2b 100644
--- a/compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt
+++ b/compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt
@@ -2,5 +2,5 @@ abstract class A {
     abstract fun foo(): Int
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>B<!>() : A() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
 }
diff --git a/compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt b/compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt
index 8fcad310a23..279bf210af7 100644
--- a/compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt
+++ b/compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt
@@ -2,5 +2,5 @@ abstract class A {
     abstract val i: Int
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>B<!>() : A() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
 }
diff --git a/compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt b/compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt
index b843856edce..11f5bde2801 100644
--- a/compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt
+++ b/compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt
@@ -2,5 +2,5 @@ abstract class A {
     abstract var i: Int
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>B<!>() : A() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class B<!>() : A() {
 }
diff --git a/compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt b/compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt
index a86867d8b90..85ec731a05b 100644
--- a/compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt
+++ b/compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt
@@ -1,6 +1,6 @@
 package extendFunctionClass
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>A<!> : Function1<Int, Int> {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class A<!> : Function1<Int, Int> {
 
 }
 
diff --git a/compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt b/compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt
index 553f9044b9f..39c650a1da5 100644
--- a/compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt
+++ b/compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt
@@ -6,6 +6,6 @@ open class B {
     open fun f(): CharSequence = "charSequence"
 }
 
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>C<!> : B(), A
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class C<!> : B(), A
 
 val obj: A = <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : B(), A {}
diff --git a/compiler/testData/diagnostics/tests/override/Generics.kt b/compiler/testData/diagnostics/tests/override/Generics.kt
index 5dbff912acf..f63317b147e 100644
--- a/compiler/testData/diagnostics/tests/override/Generics.kt
+++ b/compiler/testData/diagnostics/tests/override/Generics.kt
@@ -40,15 +40,15 @@ abstract class MyAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {
     override fun bar(t: String) = t
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R>() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalGenericClass1<!><T> : MyTrait<T>, MyAbstractClass<T>() {}
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalGenericClass2<!><T, R>(r : R) : MyTrait<T>, MyAbstractClass<R>() {
     <!NOTHING_TO_OVERRIDE!>override<!> fun foo(r: R) = r
     <!CONFLICTING_OVERLOADS!><!NOTHING_TO_OVERRIDE!>override<!> val <T> pr : R<!> = r
 }
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String>() {}
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass1<!> : MyTrait<Int>, MyAbstractClass<String>() {}
 abstract class MyLegalAbstractClass1 : MyTrait<Int>, MyAbstractClass<String>() {}
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass2<!><T>(t : T) : MyTrait<Int>, MyAbstractClass<Int>() {
     fun foo(t: T) = t
     fun bar(t: T) = t
     <!CONFLICTING_OVERLOADS!>val <R> pr : T<!> = t
diff --git a/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt b/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt
index d163ec07dde..8f1c3bd0105 100644
--- a/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt
+++ b/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt
@@ -10,4 +10,4 @@ trait C {
     fun foo(y: Int)
 }
 
-class <!MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES!>Z<!> : A, B(), C
\ No newline at end of file
+<!MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES!>class Z<!> : A, B(), C
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt b/compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt
index 3973a6e311e..1acf36d6750 100644
--- a/compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt
+++ b/compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt
@@ -6,5 +6,5 @@ trait Y {
     fun foo(a : Int = 1)
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED, MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE!>Z1<!> : X, Y {} // BUG
-object <!ABSTRACT_MEMBER_NOT_IMPLEMENTED, MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE!>Z1O<!> : X, Y {} // BUG
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED, MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE!>class Z1<!> : X, Y {} // BUG
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED, MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE!>object Z1O<!> : X, Y {} // BUG
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/NonGenerics.kt b/compiler/testData/diagnostics/tests/override/NonGenerics.kt
index c18de73a498..6b36752da73 100644
--- a/compiler/testData/diagnostics/tests/override/NonGenerics.kt
+++ b/compiler/testData/diagnostics/tests/override/NonGenerics.kt
@@ -21,21 +21,21 @@ open class MyClass() : MyTrait, MyAbstractClass() {
 
 class MyChildClass() : MyClass() {}
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass<!> : MyTrait, MyAbstractClass() {}
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass<!> : MyTrait, MyAbstractClass() {}
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass2<!>() : MyTrait, MyAbstractClass() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass2<!>() : MyTrait, MyAbstractClass() {
     override fun foo() {}
     override val pr : Unit = Unit
     override val prr : Unit = Unit
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass3<!>() : MyTrait, MyAbstractClass() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass3<!>() : MyTrait, MyAbstractClass() {
     override fun bar() {}
     override val pr : Unit = Unit
     override val prr : Unit = Unit
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyIllegalClass4<!>() : MyTrait, MyAbstractClass() {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyIllegalClass4<!>() : MyTrait, MyAbstractClass() {
     <!VIRTUAL_MEMBER_HIDDEN!>fun foo()<!> {}
     <!VIRTUAL_MEMBER_HIDDEN, MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>val pr : Unit<!>
     <!NOTHING_TO_OVERRIDE!>override<!> fun other() {}
diff --git a/compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt b/compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt
index 7f4c86e780c..3af5d5d2385 100644
--- a/compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt
+++ b/compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt
@@ -8,7 +8,7 @@ trait B {
     fun foo() = 2
 }
 
-open class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>C<!> : A, B {}
+open <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class C<!> : A, B {}
 
 trait E {
     fun foo(): Int
diff --git a/compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt b/compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt
index 19e53da4b64..b686ba515ec 100644
--- a/compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt
+++ b/compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt
@@ -12,6 +12,6 @@ open class C {
     private val a: String = ""
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Subject<!> : C(), A, B {
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Subject<!> : C(), A, B {
     val c = a
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt b/compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt
index 80789f796af..562b38d826a 100644
--- a/compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt
+++ b/compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt
@@ -8,4 +8,4 @@ trait Bar {
     fun foo(): Unit
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>Baz<!> : Foo, Bar
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Baz<!> : Foo, Bar
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/kt2052.kt b/compiler/testData/diagnostics/tests/override/kt2052.kt
index 74edd79997e..5c772f6ce8d 100644
--- a/compiler/testData/diagnostics/tests/override/kt2052.kt
+++ b/compiler/testData/diagnostics/tests/override/kt2052.kt
@@ -4,7 +4,7 @@ trait Runnable {
 
 class C {
     fun f() {
-        class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>MyRunnable<!>(): Runnable {
+        <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class MyRunnable<!>(): Runnable {
         }
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/kt4763.kt b/compiler/testData/diagnostics/tests/override/kt4763.kt
index 0bf001885ad..cf9e4e67730 100644
--- a/compiler/testData/diagnostics/tests/override/kt4763.kt
+++ b/compiler/testData/diagnostics/tests/override/kt4763.kt
@@ -6,6 +6,6 @@ open class B {
     open fun f(): CharSequence = "charSequence"
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>C<!> : B(), A
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class C<!> : B(), A
 
 val d: A = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : B(), A {}
diff --git a/compiler/testData/diagnostics/tests/override/kt4763property.kt b/compiler/testData/diagnostics/tests/override/kt4763property.kt
index 15e5cb97759..ccd9a1fe0a4 100644
--- a/compiler/testData/diagnostics/tests/override/kt4763property.kt
+++ b/compiler/testData/diagnostics/tests/override/kt4763property.kt
@@ -6,6 +6,6 @@ open class Q {
     val x: Int = 42
 }
 
-class <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>R<!> : P, Q()
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class R<!> : P, Q()
 
 val s: Q = <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : Q(), P {}
diff --git a/compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt b/compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt
index 7128e9558a4..55eb4b013ca 100644
--- a/compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt
+++ b/compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt
@@ -6,7 +6,7 @@ trait D {
     fun foo(b : Int)
 }
 
-trait <!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES!>E<!> : C, D
+<!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES!>trait E<!> : C, D
 
 trait F : C, D {
     override fun foo(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>a<!> : Int) {
diff --git a/compiler/testData/diagnostics/tests/regressions/kt302.kt b/compiler/testData/diagnostics/tests/regressions/kt302.kt
index 10128974ee2..3f5dba1ebe0 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt302.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt302.kt
@@ -10,4 +10,4 @@ trait B {
     open fun foo() {}
 }
 
-class <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>C<!> : A, B {} //should be error here
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class C<!> : A, B {} //should be error here
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/abstractClass.kt b/compiler/testData/diagnostics/tests/traitWithRequired/abstractClass.kt
index e30b00ec9c3..0d5c4873760 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/abstractClass.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/abstractClass.kt
@@ -2,6 +2,6 @@ open class Required
 
 trait Trait : Required
 
-abstract class <!UNMET_TRAIT_REQUIREMENT!>Abstract<!> : Trait
+abstract <!UNMET_TRAIT_REQUIREMENT!>class Abstract<!> : Trait
 
-abstract class <!UNMET_TRAIT_REQUIREMENT!>AbstractDerived<!> : Abstract()
+abstract <!UNMET_TRAIT_REQUIREMENT!>class AbstractDerived<!> : Abstract()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/differentGenericArguments.kt b/compiler/testData/diagnostics/tests/traitWithRequired/differentGenericArguments.kt
index 183ac1d3386..2036111c163 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/differentGenericArguments.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/differentGenericArguments.kt
@@ -4,5 +4,5 @@ trait A : Generic<Int>
 
 trait B : Generic<String>
 
-class <!UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT!>Y<!> : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>A, B<!>
+<!UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT!>class Y<!> : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>A, B<!>
 class Z : <!INCONSISTENT_TYPE_PARAMETER_VALUES!>A, B, Generic<Int>()<!>
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/kt3006.kt b/compiler/testData/diagnostics/tests/traitWithRequired/kt3006.kt
index 88ecbff53c9..1647879626d 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/kt3006.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/kt3006.kt
@@ -7,7 +7,7 @@ trait Derived: Base {
     }
 }
 
-class <!UNMET_TRAIT_REQUIREMENT!>DerivedImpl()<!>: Derived {}
-object <!UNMET_TRAIT_REQUIREMENT!>ObjectImpl<!>: Derived {}
+<!UNMET_TRAIT_REQUIREMENT!>class DerivedImpl<!>(): Derived {}
+<!UNMET_TRAIT_REQUIREMENT!>object ObjectImpl<!>: Derived {}
 
 fun f1(b: Base) = b
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/manyTraitsRequireSameClass.kt b/compiler/testData/diagnostics/tests/traitWithRequired/manyTraitsRequireSameClass.kt
index 1c0115281cd..cc313c91258 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/manyTraitsRequireSameClass.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/manyTraitsRequireSameClass.kt
@@ -8,7 +8,7 @@ trait C : Required
 
 trait D : B, Required
 
-class <!UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT!>W<!> : D
+<!UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT!>class W<!> : D
 class X : D, Required()
-class <!UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT!>Y<!> : C, D
+<!UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT, UNMET_TRAIT_REQUIREMENT!>class Y<!> : C, D
 class Z : D, C, Required()
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/requirementFulfilledBySubclass.kt b/compiler/testData/diagnostics/tests/traitWithRequired/requirementFulfilledBySubclass.kt
index 64013802cce..deb366850f0 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/requirementFulfilledBySubclass.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/requirementFulfilledBySubclass.kt
@@ -4,5 +4,5 @@ trait Trait : RequiredBase
 
 open class RequiredDerived : RequiredBase()
 
-class <!UNMET_TRAIT_REQUIREMENT!>A<!> : Trait
+<!UNMET_TRAIT_REQUIREMENT!>class A<!> : Trait
 class B : Trait, RequiredDerived()
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/traitExtendsTraitWithRequired.kt b/compiler/testData/diagnostics/tests/traitWithRequired/traitExtendsTraitWithRequired.kt
index 4d35afc516a..fec070bae77 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/traitExtendsTraitWithRequired.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/traitExtendsTraitWithRequired.kt
@@ -4,5 +4,5 @@ trait First : Required
 
 trait Second : First
 
-class <!UNMET_TRAIT_REQUIREMENT!>Y<!> : Second
+<!UNMET_TRAIT_REQUIREMENT!>class Y<!> : Second
 class Z : Second, Required(":o)")
diff --git a/idea/testData/checker/Override.kt b/idea/testData/checker/Override.kt
index 4450315a952..ac29d304646 100644
--- a/idea/testData/checker/Override.kt
+++ b/idea/testData/checker/Override.kt
@@ -15,17 +15,17 @@ package override
 
     class MyChildClass : MyClass() {}
 
-    class <error>MyIllegalClass</error> : MyTrait, MyAbstractClass() {}
+    <error>class MyIllegalClass</error> : MyTrait, MyAbstractClass() {}
 
-    class <error>MyIllegalClass2</error> : MyTrait, MyAbstractClass() {
+    <error>class MyIllegalClass2</error> : MyTrait, MyAbstractClass() {
         override fun foo() {}
     }
 
-    class <error>MyIllegalClass3</error> : MyTrait, MyAbstractClass() {
+    <error>class MyIllegalClass3</error> : MyTrait, MyAbstractClass() {
         override fun bar() {}
     }
 
-    class <error>MyIllegalClass4</error> : MyTrait, MyAbstractClass() {
+    <error>class MyIllegalClass4</error> : MyTrait, MyAbstractClass() {
         <error>fun foo()</error> {}
         <error>override</error> fun other() {}
     }
diff --git a/idea/testData/checker/OverridesAndGenerics.kt b/idea/testData/checker/OverridesAndGenerics.kt
index 009961e6adb..a932dbafd72 100644
--- a/idea/testData/checker/OverridesAndGenerics.kt
+++ b/idea/testData/checker/OverridesAndGenerics.kt
@@ -23,13 +23,13 @@
         override fun bar(t: String) = t
     }
 
-    class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T>() {}
-    class <error>MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R>() {
+    <error>class MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T>() {}
+    <error>class MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R>() {
         <error>override</error> fun foo(r: R) = r
     }
-    class <error>MyIllegalClass1</error> : MyTrait<Int>, MyAbstractClass<String>() {}
+    <error>class MyIllegalClass1</error> : MyTrait<Int>, MyAbstractClass<String>() {}
 
-    class <error>MyIllegalClass2</error><T> : MyTrait<Int>, MyAbstractClass<Int>() {
+    <error>class MyIllegalClass2</error><T> : MyTrait<Int>, MyAbstractClass<Int>() {
         fun foo(t: T) = t
         fun bar(t: T) = t
     }
diff --git a/idea/testData/checker/unmetTraitRequirements.kt b/idea/testData/checker/unmetTraitRequirements.kt
index 5b19d7489a2..4da6e136808 100644
--- a/idea/testData/checker/unmetTraitRequirements.kt
+++ b/idea/testData/checker/unmetTraitRequirements.kt
@@ -7,8 +7,8 @@ trait Derived: Base {
     }
 }
 
-class <error descr="[UNMET_TRAIT_REQUIREMENT] Super trait 'Derived' requires subclasses to extend 'Base'">DerivedImpl()</error>: Derived {}
-object <error descr="[UNMET_TRAIT_REQUIREMENT] Super trait 'Derived' requires subclasses to extend 'Base'">ObjectImpl</error>: Derived {}
+<error descr="[UNMET_TRAIT_REQUIREMENT] Super trait 'Derived' requires subclasses to extend 'Base'">class DerivedImpl</error>(): Derived {}
+<error descr="[UNMET_TRAIT_REQUIREMENT] Super trait 'Derived' requires subclasses to extend 'Base'">object ObjectImpl</error>: Derived {}
 
 fun f1(b: Base) = b