Position error on 'class A' or 'object A' instead of name identifier only

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
 

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) {

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

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<!>
 

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> {
 
 }
 

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 { }
+<!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 { }
-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 { }
+<!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 { }
-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 { }
+<!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 { }
-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 { }
+<!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 { }
-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 { }
+<!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 { }
-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 { }
+<!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 { }

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 {}
+<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class Test3<!>(a : One, b : Two) : Two by b, One by a {}

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!!
 }

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
         }
     }

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 }
     }
 }

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<!>()
 

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<!>
     }
 }
 

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() {
 }

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() {
 }

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() {
 }

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> {
 
 }
 

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 {}

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>() {}
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class 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 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

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
+<!MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE, DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES!>class Z<!> : A, B(), C

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
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED, MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE!>class 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!>object Z1O<!> : X, Y {} // BUG

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() {}

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

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
 }

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

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 {
         }
     }
 }

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 {}

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 {}

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) {

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

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()

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>()<!>

compiler/testData/diagnostics/tests/traitWithRequired/kt3006.kt

@@ -7,7 +7,7 @@ trait Derived: Base {
     }
 }
 
-class <!UNMET_TRAIT_REQUIREMENT!>DerivedImpl()<!>: Derived {}
+<!UNMET_TRAIT_REQUIREMENT!>class DerivedImpl<!>(): Derived {}
-object <!UNMET_TRAIT_REQUIREMENT!>ObjectImpl<!>: Derived {}
+<!UNMET_TRAIT_REQUIREMENT!>object ObjectImpl<!>: Derived {}
 
 fun f1(b: Base) = 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()

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()

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)")

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() {}
     }

idea/testData/checker/OverridesAndGenerics.kt

@@ -23,13 +23,13 @@
         override fun bar(t: String) = t
     }
 
-    class <error>MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T>() {}
+    <error>class MyIllegalGenericClass1</error><T> : MyTrait<T>, MyAbstractClass<T>() {}
-    class <error>MyIllegalGenericClass2</error><T, R> : MyTrait<T>, MyAbstractClass<R>() {
+    <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
     }

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 {}
+<error descr="[UNMET_TRAIT_REQUIREMENT] Super trait 'Derived' requires subclasses to extend 'Base'">class 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'">object ObjectImpl</error>: Derived {}
 
 fun f1(b: Base) = b