diff --git a/compiler/frontend/src/org/jetbrains/kotlin/checkers/DiagnosticDescriptors.kt b/compiler/frontend/src/org/jetbrains/kotlin/checkers/DiagnosticDescriptors.kt
index 0a97ba450a8..c878187bfc5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/checkers/DiagnosticDescriptors.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/checkers/DiagnosticDescriptors.kt
@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.checkers
 
-import com.google.common.collect.Maps
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.checkers.diagnostics.AbstractTestDiagnostic
 import org.jetbrains.kotlin.checkers.diagnostics.PositionalTextDiagnostic
@@ -21,7 +20,7 @@ class ActualDiagnosticDescriptor internal constructor(start: Int, end: Int, val
 
     val textDiagnosticsMap: MutableMap<AbstractTestDiagnostic, TextDiagnostic>
         get() {
-            val diagnosticMap = Maps.newLinkedHashMap<AbstractTestDiagnostic, TextDiagnostic>()
+            val diagnosticMap = mutableMapOf<AbstractTestDiagnostic, TextDiagnostic>()
             for (diagnostic in diagnostics) {
                 diagnosticMap[diagnostic] = TextDiagnostic.asTextDiagnostic(diagnostic)
             }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt
index 9952ab5f3a1..971a7f716ca 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt
@@ -549,6 +549,7 @@ object CheckerTestUtil {
         }
 
         if (diagnosticsAsText.size != 0) {
+            diagnosticsAsText.sort()
             result.append("<!${diagnosticsAsText.joinToString(", ")}!>")
             isSkip = false
         }
diff --git a/compiler/testData/diagnostics/tests/Basic.kt b/compiler/testData/diagnostics/tests/Basic.kt
index 9f860c46855..3d820e00bb1 100644
--- a/compiler/testData/diagnostics/tests/Basic.kt
+++ b/compiler/testData/diagnostics/tests/Basic.kt
@@ -10,7 +10,7 @@ fun test() : Int {
 }
 
 class A() {
-    val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo1(<!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>xx<!>)<!>
+    val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
 }
 
 fun foo1() {}
diff --git a/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt b/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
index ca348d66eef..c4142161c76 100644
--- a/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
+++ b/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
@@ -23,7 +23,7 @@ fun f(): Unit {
     <!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> !== 1<!>
 
     <!OI;DEBUG_INFO_CONSTANT!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
-    <!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!> in 1..2
+    <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> in 1..2
 
     val y : Boolean? = true
     <!UNUSED_EXPRESSION!>false || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!><!>
diff --git a/compiler/testData/diagnostics/tests/Constructors.kt b/compiler/testData/diagnostics/tests/Constructors.kt
index 5a346cb0615..82a73dbb743 100644
--- a/compiler/testData/diagnostics/tests/Constructors.kt
+++ b/compiler/testData/diagnostics/tests/Constructors.kt
@@ -14,7 +14,7 @@ class WithPC1(<!UNUSED_PARAMETER!>a<!> : Int) {
 }
 
 
-class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!SYNTAX!>this<!>() {
+class Foo() : <!FINAL_SUPERTYPE, SUPERTYPE_NOT_INITIALIZED!>WithPC0<!>, <!SYNTAX!>this<!>() {
 
 }
 
diff --git a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
index ba1eae2ef4a..c049c95fb57 100644
--- a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
+++ b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
@@ -194,7 +194,7 @@ fun testFunctionLiterals() {
     val <!UNUSED_VARIABLE!>endsWithObjectDeclaration<!> : () -> Int = {
         var <!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>x<!> = 1
         <!UNUSED_VALUE!>x =<!> 333
-        <!LOCAL_OBJECT_NOT_ALLOWED, EXPECTED_TYPE_MISMATCH!>object A<!> {}
+        <!EXPECTED_TYPE_MISMATCH, LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}
     }
 
     val <!UNUSED_VARIABLE!>expectedUnitReturnType1<!>: () -> Unit = {
diff --git a/compiler/testData/diagnostics/tests/MultipleBounds.kt b/compiler/testData/diagnostics/tests/MultipleBounds.kt
index a6f98bb96d5..94fdcfe0db6 100644
--- a/compiler/testData/diagnostics/tests/MultipleBounds.kt
+++ b/compiler/testData/diagnostics/tests/MultipleBounds.kt
@@ -48,7 +48,7 @@ class Bar<T : <!FINAL_UPPER_BOUND!>Foo<!>>
 class Buzz<T> where T : <!FINAL_UPPER_BOUND!>Bar<<!UPPER_BOUND_VIOLATED!>Int<!>><!>, T : <!UNRESOLVED_REFERENCE!>nioho<!>
 
 class X<T : <!FINAL_UPPER_BOUND!>Foo<!>>
-class Y<<!CONFLICTING_UPPER_BOUNDS!>T<!>> where T : <!FINAL_UPPER_BOUND!>Foo<!>, T : <!ONLY_ONE_CLASS_BOUND_ALLOWED, FINAL_UPPER_BOUND!>Bar<Foo><!>
+class Y<<!CONFLICTING_UPPER_BOUNDS!>T<!>> where T : <!FINAL_UPPER_BOUND!>Foo<!>, T : <!FINAL_UPPER_BOUND, ONLY_ONE_CLASS_BOUND_ALLOWED!>Bar<Foo><!>
 
 fun <T> test2(t : T)
   where
diff --git a/compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt b/compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt
index d4b38cb4974..fa84137c5a2 100644
--- a/compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt
+++ b/compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt
@@ -8,31 +8,31 @@ infix fun Any?.ddoo(a: Any) {}
 operator fun Any?.contains(a: Any): Boolean = true
 
 fun test(a: Any) {
-    1f<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
+    1f<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
     1f<!UNSUPPORTED!>foo<!> a
     1<!UNSUPPORTED!>doo<!> a
     1<!UNSUPPORTED!>ddoo<!> a
-    1<!UNSUPPORTED, INFIX_MODIFIER_REQUIRED!>contains<!> a
+    1<!INFIX_MODIFIER_REQUIRED, UNSUPPORTED!>contains<!> a
 
     1L<!UNSUPPORTED!>foo<!> a
-    1L<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
+    1L<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
     1L<!UNSUPPORTED!>Loo<!> a
 
     0b1<!UNSUPPORTED!>foo<!> a
     0b1L<!UNSUPPORTED!>foo<!> a
-    0b1L<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
+    0b1L<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
     0b1L<!UNSUPPORTED!>Loo<!> a
 
-    0xf<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
-    0xff<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
+    0xf<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
+    0xff<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
     0xfL<!UNSUPPORTED!>Loo<!> a
 
-    1.0f<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
+    1.0f<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
     1.0f<!UNSUPPORTED!>foo<!> a
     1.0<!UNSUPPORTED!>doo<!> a
     1.0<!UNSUPPORTED!>ddoo<!> a
 
-    .0f<!UNSUPPORTED, UNRESOLVED_REFERENCE!>oo<!> a
+    .0f<!UNRESOLVED_REFERENCE, UNSUPPORTED!>oo<!> a
     .0f<!UNSUPPORTED!>foo<!> a
     .0<!UNSUPPORTED!>doo<!> a
     .0<!UNSUPPORTED!>ddoo<!> a
@@ -40,10 +40,10 @@ fun test(a: Any) {
     1<!UNSUPPORTED!>in<!> a
     1.0<!UNSUPPORTED!>in<!> a
     1.0f<!UNSUPPORTED!>in<!> a
-    1.0<!UNSUPPORTED, UNRESOLVED_REFERENCE!>din<!> a
+    1.0<!UNRESOLVED_REFERENCE, UNSUPPORTED!>din<!> a
     .0<!UNSUPPORTED!>in<!> a
     .0f<!UNSUPPORTED!>in<!> a
-    .0<!UNSUPPORTED, UNRESOLVED_REFERENCE!>din<!> a
+    .0<!UNRESOLVED_REFERENCE, UNSUPPORTED!>din<!> a
 
     <!USELESS_IS_CHECK!>1<!UNSUPPORTED!>is<!> Any<!>
     1<!UNSUPPORTED!>as<!> Any
diff --git a/compiler/testData/diagnostics/tests/ResolveToJava.kt b/compiler/testData/diagnostics/tests/ResolveToJava.kt
index da19002d0a3..d3af0fcd7cb 100644
--- a/compiler/testData/diagnostics/tests/ResolveToJava.kt
+++ b/compiler/testData/diagnostics/tests/ResolveToJava.kt
@@ -21,7 +21,7 @@ fun test(<!UNUSED_PARAMETER!>l<!> : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util
 
   val <!UNUSED_VARIABLE!>f<!> : java.io.File? = null
 
-  Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, FUNCTION_CALL_EXPECTED!>emptyList<!>
+  Collections.<!FUNCTION_CALL_EXPECTED, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
   Collections.<!FUNCTION_CALL_EXPECTED!>emptyList<Int><!>
   Collections.emptyList<Int>()
   Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
diff --git a/compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt b/compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt
index 446a02b22d2..129386d1840 100644
--- a/compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt
+++ b/compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt
@@ -35,6 +35,6 @@ fun test(a: Any) {
     if(<!USELESS_IS_CHECK!>"s"<!UNSUPPORTED!>is<!> Any<!>) {}
     test("s"<!UNSUPPORTED!>as<!> Any)
 
-    a <!UNSUPPORTED!>foo<!>""<!UNSUPPORTED, SYNTAX!>1<!>
-    a <!UNSUPPORTED!>foo<!>""<!UNSUPPORTED, SYNTAX!>1.0<!>
+    a <!UNSUPPORTED!>foo<!>""<!SYNTAX, UNSUPPORTED!>1<!>
+    a <!UNSUPPORTED!>foo<!>""<!SYNTAX, UNSUPPORTED!>1.0<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/SupertypeListChecks.kt b/compiler/testData/diagnostics/tests/SupertypeListChecks.kt
index 6d345ca2bb3..f053a3fe69d 100644
--- a/compiler/testData/diagnostics/tests/SupertypeListChecks.kt
+++ b/compiler/testData/diagnostics/tests/SupertypeListChecks.kt
@@ -34,16 +34,16 @@ interface Test4 : T1 {}
 
 interface Test5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
 
-interface Test6 : <!INTERFACE_WITH_SUPERCLASS, FINAL_SUPERTYPE!>C1<!> {}
+interface Test6 : <!FINAL_SUPERTYPE, INTERFACE_WITH_SUPERCLASS!>C1<!> {}
 
 class CTest1() : OC1() {}
 
 class CTest2 : <!SUPERTYPE_NOT_INITIALIZED!>C2<!> {}
 
-class CTest3 : <!SUPERTYPE_NOT_INITIALIZED!>C2<!>, <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST!>C3<!> {}
+class CTest3 : <!SUPERTYPE_NOT_INITIALIZED!>C2<!>, <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_NOT_INITIALIZED!>C3<!> {}
 
 class CTest4 : T1 {}
 
 class CTest5 : T1, <!SUPERTYPE_APPEARS_TWICE!>T1<!> {}
 
-class CTest6 : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>C1<!> {}
\ No newline at end of file
+class CTest6 : <!FINAL_SUPERTYPE, SUPERTYPE_NOT_INITIALIZED!>C1<!> {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt
index 339fcc5587a..c4d1d299e45 100644
--- a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt
+++ b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt
@@ -1,5 +1,5 @@
 // JAVAC_EXPECTED_FILE
-interface MyTrait: <!PLATFORM_CLASS_MAPPED_TO_KOTLIN, INTERFACE_WITH_SUPERCLASS!>Object<!> {
+interface MyTrait: <!INTERFACE_WITH_SUPERCLASS, PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!> {
     override fun toString(): String
     public override fun finalize()
     <!CONFLICTING_INHERITED_JVM_DECLARATIONS!>public <!OVERRIDING_FINAL_MEMBER!>override<!> fun wait()<!>
diff --git a/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt b/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt
index 944a8b14437..a7261c4c663 100644
--- a/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt
+++ b/compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt
@@ -3,4 +3,4 @@ import java.util.ArrayList
 
 <!NI;NOT_AN_ANNOTATION_CLASS!>@<!OI;NONE_APPLICABLE!>ArrayList<!><Int>(<!NI;TOO_MANY_ARGUMENTS!>1<!>, <!NI;TOO_MANY_ARGUMENTS!>1<!>)<!> fun b() {}
 @<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>x<!>)<!> fun a() {}
\ No newline at end of file
+<!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt
index bdf7f9c3805..277ea2bd172 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt
@@ -1,12 +1,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> topFun() = 12
+fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> topFun() = 12
 
 class SomeClass {
-    fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!> T> method() = 12
+    fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!> T> method() = 12
 
     fun foo() {
-        fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> innerFun() = 12
+        fun <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> innerFun() = 12
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt
index 8e0b675731c..7b2c24f841e 100644
--- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt
+++ b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt
@@ -1,10 +1,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-val <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> T.topProp: Int get() = 12
+val <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!>  T> T.topProp: Int get() = 12
 
 class SomeClass {
-    val <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!WRONG_ANNOTATION_TARGET, REPEATED_ANNOTATION!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!> T> T.field: Int get() = 12
+    val <<!WRONG_ANNOTATION_TARGET!>@A1<!> <!WRONG_ANNOTATION_TARGET!>@A2(3)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A1(<!TOO_MANY_ARGUMENTS!>12<!>)<!> <!REPEATED_ANNOTATION, WRONG_ANNOTATION_TARGET!>@A2(<!TYPE_MISMATCH!>"Test"<!>)<!> T> T.field: Int get() = 12
 
     fun foo() {
         val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><<!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A1<!><!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!>(3)<!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!><!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A1<!>(12)<!> <!WRONG_ANNOTATION_TARGET!>@<!DEBUG_INFO_MISSING_UNRESOLVED!>A2<!>("Test")<!> T><!> <!UNUSED_VARIABLE!>localVal<!> = 12
diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.kt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.kt
index 44f7626bf03..15248efb9ed 100644
--- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.kt
+++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.kt
@@ -11,5 +11,5 @@ enum class MyEnum {
     A
 }
 
-@AnnE(<!TYPE_MISMATCH, ANNOTATION_ARGUMENT_MUST_BE_CONST!>Test()<!>)
+@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, TYPE_MISMATCH!>Test()<!>)
 class Test2
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.kt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.kt
index 4c5d23f349d..ec643868877 100644
--- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.kt
+++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.kt
@@ -6,6 +6,6 @@ fun test1(<!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@<!INAPPLICABLE_FILE_T
 <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@<!INAPPLICABLE_FILE_TARGET!>file<!> <!SYNTAX!>@<!>Suppress("")<!>
 fun test2() {}
 
-class OnType(x: <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET_ON_TYPE, WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file<!SYNTAX!><!> Suppress("")<!> Int)
+class OnType(x: <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET, WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET_ON_TYPE!>@file<!SYNTAX!><!> Suppress("")<!> Int)
 
-fun <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET_ON_TYPE, WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET!>@file : Suppress("")<!> Int.test3() {}
\ No newline at end of file
+fun <!WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET, WRONG_ANNOTATION_TARGET_WITH_USE_SITE_TARGET_ON_TYPE!>@file : Suppress("")<!> Int.test3() {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt
index a4a3f87a651..ec78e1be7ba 100644
--- a/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt
@@ -23,8 +23,8 @@ class Test {
     fun <T> List<T>.testCallable4(): () -> Unit = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<T><!>?::<!UNSAFE_CALL!>foo<!>
 
     fun <T> List<T>.testClassLiteral1() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>a<T><!>::class
-    fun <T> List<T>.testClassLiteral2() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS, EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>b<!>?::class
-    fun <T> List<T>.testClassLiteral3() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS, EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>b<T, Any><!>::class
+    fun <T> List<T>.testClassLiteral2() = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<!>?::class
+    fun <T> List<T>.testClassLiteral3() = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>b<T, Any><!>::class
 
     fun <T> List<T>.testUnresolved1() = <!UNRESOLVED_REFERENCE!>unresolved<!><T>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
     fun <T> List<T>.testUnresolved2() = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!>a<<!UNRESOLVED_REFERENCE!>unresolved<!>><!>::foo
diff --git a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt b/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
index b70eaf83c0c..81a0968b2ac 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
+++ b/compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt
@@ -27,7 +27,7 @@ fun main() {
     join(1, "4", *a, *<!TYPE_MISMATCH!>b<!>, "3")
     join(a = *a, x = 1)
     join(a = *<!TYPE_MISMATCH!>b<!>, x = 1)
-    join(a = <!TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>a<!>, x = 1)
+    join(a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>a<!>, x = 1)
 
     joinG<String>(1, "2")
     joinG<String>(<!NON_VARARG_SPREAD!>*<!>1, "2")
diff --git a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt
index b28554c4250..27d6f606ed0 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt
+++ b/compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt
@@ -9,11 +9,11 @@ fun foo(<!UNUSED_PARAMETER!>i<!>: Int, <!UNUSED_PARAMETER!>s<!>: String) {}
 
 fun test() {
 
-    bar(<!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>xx<!>)
+    bar(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
 
     bar <!TOO_MANY_ARGUMENTS!>{ }<!>
 
-    foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!UNRESOLVED_REFERENCE, TOO_MANY_ARGUMENTS!>xx<!>)
+    foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, <!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
 
     foo(<!NAMED_PARAMETER_NOT_FOUND!>r<!> = <!UNRESOLVED_REFERENCE!>xx<!>, i = <!TYPE_MISMATCH!>""<!>, s = "")
 
diff --git a/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt
index f5a74364b7e..4051a3af6a8 100644
--- a/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt
+++ b/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt
@@ -28,7 +28,7 @@ object O {
 fun f() {
     A.c
     A.hashCode()
-    A().<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>Nested<!>
+    A().<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>Nested<!>
     A.Nested()
     A().Inner()
     A.Companion.<!UNRESOLVED_REFERENCE!>Nested<!>
diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt b/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
index d41d6948ca7..cb9ce738e78 100644
--- a/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
+++ b/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt
@@ -9,7 +9,7 @@ annotation class Foo(
 
 annotation class Bar(
         val a: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>,
-        val b: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
+        val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
         val c: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
 )
 
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt
index a1054978e8d..fd9690c68f7 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt
@@ -8,7 +8,7 @@ fun testBinary2() {
 }
 
 fun testElvis1() {
-    todo() <!USELESS_ELVIS, UNREACHABLE_CODE!>?: ""<!>
+    todo() <!UNREACHABLE_CODE, USELESS_ELVIS!>?: ""<!>
 }
 
 fun testElvis2(s: String?) {
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt
index 99e4390cf1b..bb1e29a6d98 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt
@@ -50,6 +50,6 @@ fun test(arr: Array<Int>) {
     }
 
     while (true) {
-        break <!USELESS_ELVIS, UNREACHABLE_CODE!>?: null<!>
+        break <!UNREACHABLE_CODE, USELESS_ELVIS!>?: null<!>
     }
 }
diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt
index e6f2a79edf0..2d1124a13da 100644
--- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt
+++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt
@@ -9,12 +9,12 @@ class CustomDelegate {
 class Kaboom() {
     // Here and below we should have errors for simple AND delegated
     init {
-        <!UNINITIALIZED_VARIABLE, DEBUG_INFO_LEAKING_THIS!>delegated<!>.hashCode()
+        <!DEBUG_INFO_LEAKING_THIS, UNINITIALIZED_VARIABLE!>delegated<!>.hashCode()
         <!UNINITIALIZED_VARIABLE!>simple<!>.hashCode()
         <!DEBUG_INFO_LEAKING_THIS!>withGetter<!>.hashCode()
     }
 
-    val other = <!UNINITIALIZED_VARIABLE, DEBUG_INFO_LEAKING_THIS!>delegated<!>
+    val other = <!DEBUG_INFO_LEAKING_THIS, UNINITIALIZED_VARIABLE!>delegated<!>
 
     val another = <!UNINITIALIZED_VARIABLE!>simple<!>
 
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
index 16e2d27af95..4c65eddf2f2 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
@@ -98,7 +98,7 @@ fun testImplicitCoercion() {
         3 -> {
         <!IMPLICIT_CAST_TO_ANY!><!UNUSED_VALUE!>z =<!> 34<!>
     }
-        else -> <!UNUSED_CHANGED_VALUE, IMPLICIT_CAST_TO_ANY!>z--<!>
+        else -> <!IMPLICIT_CAST_TO_ANY, UNUSED_CHANGED_VALUE!>z--<!>
     }
 
     var <!UNUSED_VARIABLE!>iff<!> = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) {
@@ -108,7 +108,7 @@ fun testImplicitCoercion() {
     val <!UNUSED_VARIABLE!>h<!> = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
     bar(<!NI;TYPE_MISMATCH!>if (true) {
-        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
+        <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>4<!>
     }
         else {
         <!UNUSED_VALUE!>z =<!> 342
diff --git a/compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt b/compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt
index 31f6a82060d..ce50695c506 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt
@@ -10,7 +10,7 @@ fun f() = object : ClassData {
 fun g() = object : ClassData {
     init {
         if (true) {
-            <!RETURN_NOT_ALLOWED, RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY!>return<!> 0
+            <!RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY, RETURN_NOT_ALLOWED!>return<!> 0
         }
     }
 
diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_before.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_before.kt
index 846cae59100..ce2d253b5e7 100644
--- a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_before.kt
+++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_before.kt
@@ -8,11 +8,11 @@ object WithFunctionInBase {
 
     public class C {
         // error-scope
-        val data: <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Data<!> = Data()
+        val data: <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, DEPRECATED_ACCESS_BY_SHORT_NAME!>Data<!> = Data()
 
         open class <!CYCLIC_SCOPES_WITH_COMPANION!>Base<!>() {
             // error-scope
-            fun foo(): <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Int<!> = 42
+            fun foo(): <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, DEPRECATED_ACCESS_BY_SHORT_NAME!>Int<!> = 42
         }
 
         companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : DerivedAbstract()
@@ -30,11 +30,11 @@ object WithPropertyInBase {
 
         open class <!CYCLIC_SCOPES_WITH_COMPANION!>Base<!>() {
             // error-scope
-            val foo: <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Int<!> = 42
+            val foo: <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, DEPRECATED_ACCESS_BY_SHORT_NAME!>Int<!> = 42
         }
 
         // error-scope
-        val data: <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Data<!> = Data()
+        val data: <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, DEPRECATED_ACCESS_BY_SHORT_NAME!>Data<!> = Data()
 
         companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : DerivedAbstract()
     }
diff --git a/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt b/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt
index 305fc4bac2e..46bf53f6f40 100644
--- a/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt
+++ b/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt
@@ -1,3 +1,3 @@
 data class My(val x: Int, <!DATA_CLASS_VARARG_PARAMETER!>vararg val y: String<!>)
 
-data class Your(<!DATA_CLASS_VARARG_PARAMETER, DATA_CLASS_NOT_PROPERTY_PARAMETER!>vararg <!UNUSED_PARAMETER!>z<!>: String<!>)
\ No newline at end of file
+data class Your(<!DATA_CLASS_NOT_PROPERTY_PARAMETER, DATA_CLASS_VARARG_PARAMETER!>vararg <!UNUSED_PARAMETER!>z<!>: String<!>)
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt
index 429cef9e6e5..40d2733bbdb 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt
@@ -4,7 +4,7 @@ fun foo() {
     val x: Int? = null
     val a = Array<Int>(3, {0})
 
-    if (x != null) bar(a[<!DEBUG_INFO_SMARTCAST!>x<!>]) else bar(a[<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>])
+    if (x != null) bar(a[<!DEBUG_INFO_SMARTCAST!>x<!>]) else bar(a[<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>])
     bar(a[if (x == null) 0 else <!DEBUG_INFO_SMARTCAST!>x<!>])
     bar(a[<!TYPE_MISMATCH!>x<!>])
     
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt
index a7e3fc3535d..606bc3be388 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt
@@ -6,6 +6,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!NI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> else x<!>)
+    bar(<!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!> else x<!>)
     if (x != null) bar(x + x/(x-x*x))
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt
index 690adabc345..a2a2b5f470d 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt
@@ -17,14 +17,14 @@ fun foo() {
         if (<!SENSELESS_COMPARISON!>x == null<!>) bar(x) else bar(x)
         bar(bar(x))
     } else if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>x<!> == null<!>) {
-        bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>)
+        bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
         if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>x<!> != null<!>) {
             bar(x)
             if (<!SENSELESS_COMPARISON!>x == null<!>) bar(x)
             if (<!SENSELESS_COMPARISON!>x == null<!>) bar(x) else bar(x)
             bar(bar(x) + bar(x))
         } else if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>x<!> == null<!>) {
-            bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>)
+            bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
         }
     }
 
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt
index 672242926e3..01de3666935 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt
@@ -12,5 +12,5 @@ fun foo() {
     do {
         bar(<!TYPE_MISMATCH!>y<!>)
     } while (y != null)
-    bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>y<!>)
+    bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt
index 466c13ee838..9bf7a1753fe 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt
@@ -6,7 +6,7 @@ fun foo() {
     bar(if (x == null) 0 else <!DEBUG_INFO_SMARTCAST!>x<!>)
 
     if (x == null) {
-        bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>)
+        bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
         return
     } else {
         bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt
index 6b334509680..d06b327315e 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt
@@ -7,6 +7,6 @@ fun foo() {
 
     val <!UNUSED_VARIABLE!>a<!> = object {
         fun baz() = bar(if (x == null) 0 else <!DEBUG_INFO_SMARTCAST!>x<!>)
-        fun quux(): Int = <!NI;TYPE_MISMATCH!>if (x == null) <!OI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!> else <!DEBUG_INFO_SMARTCAST!>x<!><!>
+        fun quux(): Int = <!NI;TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>x<!> else <!DEBUG_INFO_SMARTCAST!>x<!><!>
     }
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
index 4f40d73a77c..29792de3840 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
@@ -9,10 +9,10 @@ fun foo(): Int {
     if (x != null) return x
     
     val y: Int? = null
-    if (y == null) return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>y<!> != null<!>) y else <!OI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>y<!><!>
+    if (y == null) return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (<!SENSELESS_COMPARISON!><!DEBUG_INFO_CONSTANT!>y<!> != null<!>) y else <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>y<!><!>
     
     val z: Int? = null
     if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z
     
-    return <!NI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>
+    return <!DEBUG_INFO_CONSTANT, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z<!>
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt
index 02af52d4470..639a0abd7ee 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt
@@ -16,6 +16,6 @@ class Derived : Base() {
 
         val y: Int? = null
         if (y != null) super.bar(this.baz(<!DEBUG_INFO_SMARTCAST!>y<!>))
-        else this.baz(super.bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>y<!>))
+        else this.baz(super.bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>))
     }
 }
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt
index 11762476d12..daba3a817f0 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt
@@ -3,7 +3,7 @@ fun bar(x: Int): RuntimeException = RuntimeException(x.toString())
 fun foo() {
     val x: Int? = null
 
-    if (x == null) throw bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>)
+    if (x == null) throw bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
     throw bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
     <!UNREACHABLE_CODE!>throw bar(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt
index 945f49932fa..fd01fee12cb 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt
@@ -3,7 +3,7 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
     val x: Int? = null
     while (x == null) {
-        bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>)
+        bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
     }
     bar(<!DEBUG_INFO_SMARTCAST!>x<!>)
     
@@ -11,11 +11,11 @@ fun foo() {
     while (y != null) {
         bar(<!DEBUG_INFO_SMARTCAST!>y<!>)
     }
-    bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>y<!>)
+    bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>y<!>)
     
     val z: Int? = null
     while (z == null) {
-        bar(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>z<!>)
+        bar(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>)
         break
     }
     bar(<!TYPE_MISMATCH!>z<!>)
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt b/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt
index 247d5892d79..2e3778aa182 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt
@@ -3,17 +3,17 @@ annotation class a
 interface A
 interface B
 
-<!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun ()<!> {}
-<!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun A.()<!> {}
+<!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {}
+<!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>fun A.()<!> {}
 
-<!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>@a fun ()<!> {}
-<!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun @a A.()<!> {}
+<!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>@a fun ()<!> {}
+<!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>fun @a A.()<!> {}
 
 class Outer {
-    <!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun ()<!> {}
+    <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {}
     <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun B.()<!> {}
 
-    <!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>@a fun ()<!> {}
+    <!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>@a fun ()<!> {}
     <!FUNCTION_DECLARATION_WITH_NO_NAME!>fun @a A.()<!> {}
 }
 
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt b/compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt
index 592a462d586..50c309fa4d6 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt
@@ -1,3 +1,3 @@
 fun test() {
-    val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER, UNUSED_VARIABLE!>a<!>
+    val <!UNUSED_VARIABLE, VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>a<!>
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt
index 4215add1e0d..9b5dba7c613 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt
@@ -1,8 +1,8 @@
 // !WITH_NEW_INFERENCE
 fun useDeclaredVariables() {
     for ((a, b)<!SYNTAX!><!>) {
-        <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
-        <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt
index 145735a840c..c19fbf84ee8 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt
@@ -1,7 +1,7 @@
 fun useDeclaredVariables() {
     val (a, b) = <!UNRESOLVED_REFERENCE!>unresolved<!>
-    <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
-    <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
 }
 
 fun checkersShouldRun() {
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt
index b8bb6e327dd..6de91aca333 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt
@@ -1,7 +1,7 @@
 fun useDeclaredVariables() {
     <!INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION!>val (a, b)<!>
-    <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
-    <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
 }
 
 fun checkersShouldRun() {
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
index de77a4a7c93..786d0a55f99 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
@@ -43,7 +43,7 @@ fun test() {
 
     val (_, <!NAME_SHADOWING, REDECLARATION!>`_`<!>) = A()
 
-    foo(<!UNDERSCORE_USAGE_WITHOUT_BACKTICKS, TYPE_MISMATCH!>_<!>, y)
+    foo(<!TYPE_MISMATCH, UNDERSCORE_USAGE_WITHOUT_BACKTICKS!>_<!>, y)
 
     val (<!UNUSED_VARIABLE!>unused<!>, _) = A()
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt b/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt
index d816dd7182f..7cd5681ab25 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt
@@ -6,7 +6,7 @@ class T {
 
 fun foo() {
     <!WRONG_MODIFIER_TARGET!>public<!> val <!UNUSED_VARIABLE!>i<!> = 11
-    <!WRONG_MODIFIER_TARGET!>abstract<!> val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER, UNUSED_VARIABLE!>j<!>
+    <!WRONG_MODIFIER_TARGET!>abstract<!> val <!UNUSED_VARIABLE, VARIABLE_WITH_NO_TYPE_NO_INITIALIZER!>j<!>
     <!WRONG_MODIFIER_TARGET!>override<!> fun T.<!EXTENSION_SHADOWED_BY_MEMBER!>baz<!>() = 2
     <!WRONG_MODIFIER_TARGET!>private<!> fun bar() = 2
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt
index 06cb917614c..17274dcb27d 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt
@@ -11,7 +11,7 @@ operator fun <T> String.provideDelegate(receiver: Any?, p: Any) = Delegate<T>()
 var test1: String by <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Delegate<!>()
 var test2: String by Delegate<String>()
 
-var test3: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_MISSING!>"OK"<!>
+var test3: String by <!DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
 
 var test4: String by "OK".<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>provideDelegate<!>(null, "")
 var test5: String by "OK".provideDelegate<String>(null, "")
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt
index c03053ddd7e..8d64edc5bf6 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt
@@ -8,7 +8,7 @@ val a by <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;TYPECHECKER_HAS_RUN_INTO_RE
 
 val b by Delegate(<!OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
 
-val c by <!UNINITIALIZED_VARIABLE, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>d<!>
+val c by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNINITIALIZED_VARIABLE!>d<!>
 val d by <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>
 
 class Delegate(i: Int) {
diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt
index 38d91fa982d..570a40e173e 100644
--- a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt
+++ b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt
@@ -1,4 +1,4 @@
 // JAVAC_EXPECTED_FILE
 class TestIface(r : Runnable) : Runnable by r {}
 
-class TestObject(o : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>) : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN, DELEGATION_NOT_TO_INTERFACE!>Object<!> by o {}
\ No newline at end of file
+class TestObject(o : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!>) : <!DELEGATION_NOT_TO_INTERFACE, PLATFORM_CLASS_MAPPED_TO_KOTLIN!>Object<!> by o {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt b/compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt
index f97ee93a280..ddaaec96f72 100644
--- a/compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt
+++ b/compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt
@@ -6,7 +6,7 @@ open class IDerived1 : IBase1 {
     override fun foo(): String = "1"
 }
 
-<!RETURN_TYPE_MISMATCH_BY_DELEGATION, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class Broken1<!>(val b: IBase1) : IBase1 by b, IDerived1()
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, RETURN_TYPE_MISMATCH_BY_DELEGATION!>class Broken1<!>(val b: IBase1) : IBase1 by b, IDerived1()
 
 interface IBase2 {
     val foo: Any
@@ -16,4 +16,4 @@ open class IDerived2 : IBase2 {
     override val foo: String = "2"
 }
 
-<!PROPERTY_TYPE_MISMATCH_BY_DELEGATION, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class Broken2<!>(val b: IBase2) : IBase2 by b, IDerived2()
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, PROPERTY_TYPE_MISMATCH_BY_DELEGATION!>class Broken2<!>(val b: IBase2) : IBase2 by b, IDerived2()
diff --git a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt
index 5d4dc4857a9..61dd6580443 100644
--- a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt
+++ b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt
@@ -23,19 +23,19 @@ class ImplAll : Base, Base2, Base3 {
 }
 
 fun box(): String {
-    <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>object<!> : Base2, Base3, Base by Impl() {
+    <!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : Base2, Base3, Base by Impl() {
 
     }
 
-    <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>object<!> : Base2 by Impl2(), Base3, Base {
+    <!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : Base2 by Impl2(), Base3, Base {
 
     }
 
-    <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>object<!> : Base2, Base3 by Impl3(), Base {
+    <!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : Base2, Base3 by Impl3(), Base {
 
     }
 
-    <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>object<!> : Base2 by Impl2(), Base3 by Impl3(), Base by Impl() {
+    <!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : Base2 by Impl2(), Base3 by Impl3(), Base by Impl() {
 
     }
 
diff --git a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt
index 72be577b870..91de29cdf30 100644
--- a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt
+++ b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt
@@ -14,7 +14,7 @@ class Delegate : Derived {
 public open class MyClass : Base by Delegate()
 
 fun box(): String {
-    <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>object<!> : MyClass(), Derived by Delegate() {
+    <!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : MyClass(), Derived by Delegate() {
     }
     return "OK"
 }
diff --git a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt
index 8ccce102da5..1ff9963b1ee 100644
--- a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt
+++ b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt
@@ -23,6 +23,6 @@ public abstract class MyClass : Base1, Base2 {
     }
 }
 
-<!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Delegate2()<!> {
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Delegate2()<!> {
 
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt
index 96770388a9c..a6bc8ff3831 100644
--- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt
+++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt
@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -DUPLICATE_CLASS_NAMES
-<!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun ()<!> {
+<!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {
 
 }
 
diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt b/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt
index 768784939f9..f2ff95977a5 100644
--- a/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt
+++ b/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt
@@ -20,7 +20,7 @@ public class J {
 import p.*
 
 class K: J.C() {
-    fun <!UNSUPPORTED, DYNAMIC_RECEIVER_NOT_ALLOWED!>dynamic<!>.test() {
+    fun <!DYNAMIC_RECEIVER_NOT_ALLOWED, UNSUPPORTED!>dynamic<!>.test() {
         <!DEBUG_INFO_DYNAMIC!>sam<!>(null)
         <!DEBUG_INFO_DYNAMIC!>sam<!>(
             name = null,
diff --git a/compiler/testData/diagnostics/tests/enum/enumInheritance.kt b/compiler/testData/diagnostics/tests/enum/enumInheritance.kt
index ff0f2a425fc..60e7887cefc 100644
--- a/compiler/testData/diagnostics/tests/enum/enumInheritance.kt
+++ b/compiler/testData/diagnostics/tests/enum/enumInheritance.kt
@@ -1,7 +1,7 @@
 // FILE: test.kt
 enum class MyEnum(): <!CLASS_IN_SUPERTYPE_FOR_ENUM!>MyClass<!>() {}
 enum class MyEnum2(): MyTrait {}
-enum class MyEnum3(): <!INVISIBLE_MEMBER, CLASS_IN_SUPERTYPE_FOR_ENUM, FINAL_SUPERTYPE!>MyEnumBase<!>() {}
+enum class MyEnum3(): <!CLASS_IN_SUPERTYPE_FOR_ENUM, FINAL_SUPERTYPE, INVISIBLE_MEMBER!>MyEnumBase<!>() {}
 
 open class MyClass() {}
 
diff --git a/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt b/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt
index b4f3ac1e3a4..67b5b7daba8 100644
--- a/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt
+++ b/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt
@@ -8,6 +8,6 @@ public enum MyJavaEnum {}
 
 enum class MyEnum2() {}
 
-class MyClass(): <!INVISIBLE_MEMBER, FINAL_SUPERTYPE!>MyEnum2<!>() {}
+class MyClass(): <!FINAL_SUPERTYPE, INVISIBLE_MEMBER!>MyEnum2<!>() {}
 
 class MyClass2(): <!FINAL_SUPERTYPE!>MyJavaEnum<!>() {}
diff --git a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt
index 63c018a72c0..ea1c09a76d5 100644
--- a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt
@@ -12,7 +12,7 @@ val a7 = <!DIVISION_BY_ZERO!>1.div(a1)<!>
 val a8 = 1.div(a2)
 val a9 = 2 * (<!DIVISION_BY_ZERO!>1.div(0)<!>)
 
-val b1: Byte = <!NI;TYPE_MISMATCH, DIVISION_BY_ZERO, TYPE_MISMATCH!>1 / 0<!>
-@Ann(<!DIVISION_BY_ZERO, ANNOTATION_ARGUMENT_MUST_BE_CONST!>1 / 0<!>) val b2 = 1
+val b1: Byte = <!DIVISION_BY_ZERO, NI;TYPE_MISMATCH, TYPE_MISMATCH!>1 / 0<!>
+@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, DIVISION_BY_ZERO!>1 / 0<!>) val b2 = 1
 
 annotation class Ann(val i : Int)
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
index ce65a8f7486..cb87406a4d8 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt
@@ -26,7 +26,7 @@ fun test1() {
         <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>x<!>, <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>y<!><!> -> ""
     }<!>
     foo1 <!NI;TYPE_MISMATCH!>{
-        <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
+        <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
     }<!>
 
 
@@ -40,6 +40,6 @@ fun test1() {
         <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH, UNUSED_ANONYMOUS_PARAMETER!>x<!> -> ""
     }<!>
     foo2 <!NI;TYPE_MISMATCH!>{
-         <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
+         <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!>-> <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>
     }<!>
 }
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt
index c553b404621..318589a70ab 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt
@@ -5,5 +5,5 @@ val a = l@ {
 val b = l@ {
     if ("" == "OK") return@l
 
-    return@l <!UNRESOLVED_REFERENCE, RETURN_TYPE_MISMATCH!>r<!>
+    return@l <!RETURN_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>r<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt
index a9c1c6fa511..32877a619a6 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt
@@ -17,7 +17,7 @@ fun foo(x: Any?, y: C<*>) {
 
     with(x) {
         if (this is C<*>) {
-            <!OI;MEMBER_PROJECTED_OUT, DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
+            <!DEBUG_INFO_IMPLICIT_RECEIVER_SMARTCAST, OI;MEMBER_PROJECTED_OUT!>bindTo<!>(<!NI;TYPE_MISMATCH!>""<!>)
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt
index 325bbe9e0aa..223bc346c43 100644
--- a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt
+++ b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt
@@ -21,7 +21,7 @@ fun all(a: String) {}
 
 // FILE: 2.kt
 
-import k.<!INVISIBLE_REFERENCE, DEBUG_INFO_MISSING_UNRESOLVED!>zero<!>
+import k.<!DEBUG_INFO_MISSING_UNRESOLVED, INVISIBLE_REFERENCE!>zero<!>
 import k.one
 import k.two
 import k.all
diff --git a/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt b/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt
index fd756a7e265..1919f02f6de 100644
--- a/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt
+++ b/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt
@@ -8,4 +8,4 @@ package a
 
 import pack1.*
 
-private class X : <!INVISIBLE_REFERENCE, INVISIBLE_MEMBER!>SomeClass<!>()
\ No newline at end of file
+private class X : <!INVISIBLE_MEMBER, INVISIBLE_REFERENCE!>SomeClass<!>()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt b/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt
index b8cf2d32a2f..496ea86f828 100644
--- a/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt
+++ b/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt
@@ -11,4 +11,4 @@ package a
 
 import pack1.SomeClass.*
 
-private class X : <!INVISIBLE_REFERENCE, INVISIBLE_MEMBER, FINAL_SUPERTYPE!>N<!>()
\ No newline at end of file
+private class X : <!FINAL_SUPERTYPE, INVISIBLE_MEMBER, INVISIBLE_REFERENCE!>N<!>()
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt
index 2ae7ece0c1d..32df9a0b9aa 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt
@@ -7,7 +7,7 @@ interface A<T>
 fun <T> infer(<!UNUSED_PARAMETER!>a<!>: A<T>) : T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 fun test(nothing: Nothing?) {
-    <!NI;UNREACHABLE_CODE!>val <!UNUSED_VARIABLE!>i<!> =<!> <!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>infer<!>(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>nothing<!>)
+    <!NI;UNREACHABLE_CODE!>val <!UNUSED_VARIABLE!>i<!> =<!> <!OI;TYPE_INFERENCE_INCORPORATION_ERROR!>infer<!>(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>nothing<!>)
 }
 
 fun sum(<!UNUSED_PARAMETER!>a<!> : IntArray) : Int {
diff --git a/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt b/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt
index 5e88a21ab2a..63cec9e0adc 100644
--- a/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt
+++ b/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt
@@ -10,7 +10,7 @@ class Foo {
 
 fun x(f : Foo) {
     f.<!FUNCTION_CALL_EXPECTED!>prop<!>
-    f.<!NO_VALUE_FOR_PARAMETER, FUNCTION_CALL_EXPECTED!>bar<!>
+    f.<!FUNCTION_CALL_EXPECTED, NO_VALUE_FOR_PARAMETER!>bar<!>
 
     f.<!FUNCTION_EXPECTED!>a<!>()
     <!UNRESOLVED_REFERENCE!>c<!>()
diff --git a/compiler/testData/diagnostics/tests/inline/parenthesized.kt b/compiler/testData/diagnostics/tests/inline/parenthesized.kt
index 046f9755a7f..35ffeead895 100644
--- a/compiler/testData/diagnostics/tests/inline/parenthesized.kt
+++ b/compiler/testData/diagnostics/tests/inline/parenthesized.kt
@@ -4,7 +4,7 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit) {
     (s)(11)
     (s).invoke(11)
     (s) <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
-    (<!USAGE_IS_NOT_INLINABLE, UNUSED_EXPRESSION!>s<!>)
+    (<!UNUSED_EXPRESSION, USAGE_IS_NOT_INLINABLE!>s<!>)
 }
 
 <!NOTHING_TO_INLINE!>inline<!> fun Function1<Int, Unit>.inlineExt() {
@@ -18,7 +18,7 @@ inline fun inlineFunWithInvoke2(s: (p: Int) -> Unit) {
     (((s)))(11)
     (((s))).invoke(11)
     (((s))) <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
-    (((<!USAGE_IS_NOT_INLINABLE, UNUSED_EXPRESSION!>s<!>)))
+    (((<!UNUSED_EXPRESSION, USAGE_IS_NOT_INLINABLE!>s<!>)))
 }
 
 inline fun propagation(s: (p: Int) -> Unit) {
diff --git a/compiler/testData/diagnostics/tests/inline/sam.kt b/compiler/testData/diagnostics/tests/inline/sam.kt
index 2a0b0d86cab..39b4fbc83a3 100644
--- a/compiler/testData/diagnostics/tests/inline/sam.kt
+++ b/compiler/testData/diagnostics/tests/inline/sam.kt
@@ -22,8 +22,8 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
         11.ext(11)
         11 <!INFIX_MODIFIER_REQUIRED!>ext<!> 11
 
-        <!USAGE_IS_NOT_INLINABLE, UNUSED_EXPRESSION!>s<!>
-        <!USAGE_IS_NOT_INLINABLE, UNUSED_EXPRESSION!>ext<!>
+        <!UNUSED_EXPRESSION, USAGE_IS_NOT_INLINABLE!>s<!>
+        <!UNUSED_EXPRESSION, USAGE_IS_NOT_INLINABLE!>ext<!>
         11
     }
 }
@@ -38,7 +38,7 @@ inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit, ext: Int.(
         11 <!INFIX_MODIFIER_REQUIRED!>ext<!> 11
 
         <!UNUSED_EXPRESSION!>s<!>
-        <!USAGE_IS_NOT_INLINABLE, UNUSED_EXPRESSION!>ext<!>
+        <!UNUSED_EXPRESSION, USAGE_IS_NOT_INLINABLE!>ext<!>
 
         11
     }
diff --git a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt
index 1702c497333..e441ee22671 100644
--- a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt
+++ b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt
@@ -1,6 +1,6 @@
 class Test {
     @`InnerAnnotation` <!REPEATED_ANNOTATION!>@InnerAnnotation<!>
-    companion <!CYCLIC_SCOPES_WITH_COMPANION, CYCLIC_SCOPES_WITH_COMPANION!>object<!> : StaticClass(), <!UNRESOLVED_REFERENCE, MANY_CLASSES_IN_SUPERTYPE_LIST, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>InnerClass<!>() {
+    companion <!CYCLIC_SCOPES_WITH_COMPANION, CYCLIC_SCOPES_WITH_COMPANION!>object<!> : StaticClass(), <!DEBUG_INFO_UNRESOLVED_WITH_TARGET, MANY_CLASSES_IN_SUPERTYPE_LIST, UNRESOLVED_REFERENCE!>InnerClass<!>() {
 
     }
 
diff --git a/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt b/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt
index 42df6333fee..696fffe1bb4 100644
--- a/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt
+++ b/compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt
@@ -5,8 +5,8 @@ class TestSome<P> {
 }
 
 class Test {
-    companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : <!UNRESOLVED_REFERENCE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>InnerClass<!>() {
-        val a = object: <!UNRESOLVED_REFERENCE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>InnerClass<!>() {
+    companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : <!DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>InnerClass<!>() {
+        val a = object: <!DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>InnerClass<!>() {
         }
 
         fun more(): InnerClass {
diff --git a/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt b/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt
index e2752bf0eba..bb960cc2405 100644
--- a/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt
+++ b/compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt
@@ -5,8 +5,8 @@ class TestSome<P> {
 }
 
 class Test {
-    object Some : <!UNRESOLVED_REFERENCE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>InnerClass<!>() {
-        val a = object: <!UNRESOLVED_REFERENCE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>InnerClass<!>() {
+    object Some : <!DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>InnerClass<!>() {
+        val a = object: <!DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>InnerClass<!>() {
         }
 
         fun more(): InnerClass {
diff --git a/compiler/testData/diagnostics/tests/inner/modality.kt b/compiler/testData/diagnostics/tests/inner/modality.kt
index 693081811fd..db8da383fe9 100644
--- a/compiler/testData/diagnostics/tests/inner/modality.kt
+++ b/compiler/testData/diagnostics/tests/inner/modality.kt
@@ -7,7 +7,7 @@ class Outer {
 
     class Nested1 : OpenNested()
     class Nested2 : <!FINAL_SUPERTYPE!>FinalNested<!>()
-    class Nested3 : <!UNRESOLVED_REFERENCE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>OpenInner<!>()
+    class Nested3 : <!DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>OpenInner<!>()
     class Nested4 : <!FINAL_SUPERTYPE!>FinalInner<!>()
 
     inner class Inner1 : OpenNested()
diff --git a/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt b/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt
index 25cc3aac86b..8a773d7b240 100644
--- a/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt
+++ b/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt
@@ -25,28 +25,28 @@ object Obj {
 
 fun test(with: WithClassObject, without: WithoutClassObject, obj: Obj) {
     with.<!UNRESOLVED_REFERENCE!>Nested<!>()
-    with.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
+    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedWithClassObject<!>
     with.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
-    with.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
-    with.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedEnum<!>.A
+    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedWithClassObject<!>.foo()
+    with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedEnum<!>.A
     with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>
     with.<!RESOLUTION_TO_CLASSIFIER!>NestedObj<!>()
     with.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>.foo()
 
     without.<!UNRESOLVED_REFERENCE!>Nested<!>()
-    without.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
+    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedWithClassObject<!>
     without.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
-    without.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
-    without.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedEnum<!>.A
+    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedWithClassObject<!>.foo()
+    without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedEnum<!>.A
     without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>
     without.<!RESOLUTION_TO_CLASSIFIER!>NestedObj<!>()
     without.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>.foo()
 
     obj.<!UNRESOLVED_REFERENCE!>Nested<!>()
-    obj.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>
+    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedWithClassObject<!>
     obj.<!UNRESOLVED_REFERENCE!>NestedWithClassObject<!>()
-    obj.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedWithClassObject<!>.foo()
-    obj.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedEnum<!>.A
+    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedWithClassObject<!>.foo()
+    obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>NestedEnum<!>.A
     obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>
     obj.<!RESOLUTION_TO_CLASSIFIER!>NestedObj<!>()
     obj.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>NestedObj<!>.foo()
diff --git a/compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt b/compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt
index db64efbde5c..3580249bf80 100644
--- a/compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt
+++ b/compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt
@@ -8,5 +8,5 @@ public class X {
 
 class A : X() {
     // TODO: DEBUG_INFO_MISSING_UNRESOLVED indicates a bug here
-    override fun getFoo() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    override fun getFoo() = <!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/kt310.kt b/compiler/testData/diagnostics/tests/kt310.kt
index 8ed71ce728f..d6418045280 100644
--- a/compiler/testData/diagnostics/tests/kt310.kt
+++ b/compiler/testData/diagnostics/tests/kt310.kt
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
 
 fun f(c: LongRange): Int {
-    return c.<!NI;TYPE_MISMATCH, FUNCTION_EXPECTED!>start<!>()
+    return c.<!FUNCTION_EXPECTED, NI;TYPE_MISMATCH!>start<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
index 5318cfdfede..eac597e4a5d 100644
--- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
+++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
@@ -87,7 +87,7 @@ abstract class IllegalModifiers6() {
 
     <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_ANNOTATION_TARGET!>@annotated<!> init {}
 
-    <!WRONG_MODIFIER_TARGET!>private<!> <!WRONG_ANNOTATION_TARGET, NOT_AN_ANNOTATION_CLASS!>@IllegalModifiers6()<!> init {}
+    <!WRONG_MODIFIER_TARGET!>private<!> <!NOT_AN_ANNOTATION_CLASS, WRONG_ANNOTATION_TARGET!>@IllegalModifiers6()<!> init {}
 }
 
 // strange inappropriate modifiers usages
diff --git a/compiler/testData/diagnostics/tests/modifiers/const/types.kt b/compiler/testData/diagnostics/tests/modifiers/const/types.kt
index 674e83339b8..dd7b10405fb 100644
--- a/compiler/testData/diagnostics/tests/modifiers/const/types.kt
+++ b/compiler/testData/diagnostics/tests/modifiers/const/types.kt
@@ -13,5 +13,5 @@ enum class MyEnum { A }
 
 const val unresolvedConst1 = <!UNRESOLVED_REFERENCE!>Unresolved<!>
 <!WRONG_MODIFIER_TARGET!>const<!> var unresolvedConst2 = <!UNRESOLVED_REFERENCE!>Unresolved<!>
-const val unresolvedConst3 = <!UNRESOLVED_REFERENCE, PROPERTY_INITIALIZER_NO_BACKING_FIELD!>Unresolved<!>
+const val unresolvedConst3 = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD, UNRESOLVED_REFERENCE!>Unresolved<!>
 <!CONST_VAL_WITH_GETTER!>get() = 10<!>
diff --git a/compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt b/compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt
index c45a1bbf519..f12cc694024 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt
@@ -11,5 +11,5 @@ expect enum class En<!EXPECTED_ENUM_CONSTRUCTOR!>(x: Int)<!> {
 }
 
 expect enum class En2 {
-    E1<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, NO_CONSTRUCTOR!>()<!>
+    E1<!NO_CONSTRUCTOR, SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!>
 }
diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt
index 69e9678e471..7951a02092f 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt
@@ -4,7 +4,7 @@
 
 expect open class A
 expect class B : A
-open class C : <!SUPERTYPE_NOT_INITIALIZED, JVM:SUPERTYPE_NOT_INITIALIZED!>A<!>
+open class C : <!JVM:SUPERTYPE_NOT_INITIALIZED, SUPERTYPE_NOT_INITIALIZED!>A<!>
 
 // MODULE: m1-jvm(m1-common)
 // FILE: jvm.kt
diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt
index 64dabad62b0..c9ae7381976 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt
@@ -23,6 +23,6 @@ actual <!ACTUAL_WITHOUT_EXPECT!>var<!> s: String = "value"
 
 fun <!ACTUAL_MISSING!>foo2<!>(): Int = 0
 
-actual class <!PACKAGE_OR_CLASSIFIER_REDECLARATION, ACTUAL_WITHOUT_EXPECT!>Foo3<!>
+actual class <!ACTUAL_WITHOUT_EXPECT, PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!>
 
-class <!PACKAGE_OR_CLASSIFIER_REDECLARATION, ACTUAL_WITHOUT_EXPECT!>Foo3<!>
+class <!ACTUAL_WITHOUT_EXPECT, PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo3<!>
diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt
index ffcd9272a1b..e2802eb26a2 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt
@@ -3,7 +3,7 @@
 // FILE: common.kt
 
 expect class H {
-    <!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> fun foo()
+    <!JVM:WRONG_MODIFIER_TARGET, WRONG_MODIFIER_TARGET!>expect<!> fun foo()
 }
 
 // MODULE: m1-jvm(m1-common)
diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt
index 275ddef2043..fed08086bf3 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt
@@ -5,14 +5,14 @@
 expect class B {
     class N {
         <!EXPECTED_DECLARATION_WITH_BODY, JVM:EXPECTED_DECLARATION_WITH_BODY!>fun body()<!> {}
-        <!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> fun extraHeader()
+        <!JVM:WRONG_MODIFIER_TARGET, WRONG_MODIFIER_TARGET!>expect<!> fun extraHeader()
     }
 }
 
 expect class C {
-    <!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> class N
-    <!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> enum class E
-    <!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> inner class I
+    <!JVM:WRONG_MODIFIER_TARGET, WRONG_MODIFIER_TARGET!>expect<!> class N
+    <!JVM:WRONG_MODIFIER_TARGET, WRONG_MODIFIER_TARGET!>expect<!> enum class E
+    <!JVM:WRONG_MODIFIER_TARGET, WRONG_MODIFIER_TARGET!>expect<!> inner class I
 }
 
 expect class D {
diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt
index 61548794f20..37707af6feb 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt
@@ -8,7 +8,7 @@ interface J
 
 expect class Foo : I, C, J
 
-expect class Bar : <!SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, JS:SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, JVM:SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>C<!SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, JS:SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, JVM:SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!><!>
+expect class Bar : <!JS:SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, JVM:SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR, SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR!>C<!JS:SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, JVM:SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS, SUPERTYPE_INITIALIZED_IN_EXPECTED_CLASS!>()<!><!>
 
 // MODULE: m2-jvm(m1-common)
 // FILE: jvm.kt
diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt b/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt
index b04f0649f28..e2e30547342 100644
--- a/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt
+++ b/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt
@@ -3,7 +3,7 @@
 // FILE: common.kt
 
 class Foo {
-    <!NON_ABSTRACT_FUNCTION_WITH_NO_BODY, JVM:NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!WRONG_MODIFIER_TARGET, JVM:WRONG_MODIFIER_TARGET!>expect<!> fun bar(): String<!>
+    <!JVM:NON_ABSTRACT_FUNCTION_WITH_NO_BODY, NON_ABSTRACT_FUNCTION_WITH_NO_BODY!><!JVM:WRONG_MODIFIER_TARGET, WRONG_MODIFIER_TARGET!>expect<!> fun bar(): String<!>
 }
 
 // MODULE: m1-jvm(m1-common)
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt
index aa12cbaf575..073e4f2e281 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt
@@ -26,7 +26,7 @@ fun f3(s: Int?): Int {
 fun f4(s: Int?): Int {
     return <!NI;TYPE_MISMATCH!>when {
         s == 4 -> <!DEBUG_INFO_SMARTCAST!>s<!>
-        s == null -> <!OI;TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>s<!>
+        s == null -> <!DEBUG_INFO_CONSTANT, OI;TYPE_MISMATCH!>s<!>
         else -> <!DEBUG_INFO_SMARTCAST!>s<!>
     }<!>
 }
diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
index 8037571281d..0b4f9a7dc02 100644
--- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
+++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt
@@ -22,7 +22,7 @@ fun main() {
         foo(x<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>)
         foo(<!DEBUG_INFO_SMARTCAST!>x<!>)
     } else {
-        foo(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>x<!>)
+        foo(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!>)
         <!OI;UNREACHABLE_CODE!>foo(<!><!ALWAYS_NULL!>x<!>!!<!OI;UNREACHABLE_CODE!>)<!>
         <!OI;UNREACHABLE_CODE!>foo(<!DEBUG_INFO_SMARTCAST!>x<!>)<!>
     }
diff --git a/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt b/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt
index 74bd4f14a30..2bbe756f018 100644
--- a/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt
+++ b/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt
@@ -13,5 +13,5 @@ fun main() {
     //not 'An integer literal does not conform to the expected type Int/Long'
     val <!UNUSED_VARIABLE!>l<!>: Long = <!INT_LITERAL_OUT_OF_RANGE!>1111111111111117777777777777777<!>
     foo(<!INT_LITERAL_OUT_OF_RANGE!>11111111111111177777777777777<!>)
-    bar(<!NI;TYPE_MISMATCH, INT_LITERAL_OUT_OF_RANGE!>11111111111111177777777777777<!>)
+    bar(<!INT_LITERAL_OUT_OF_RANGE, NI;TYPE_MISMATCH!>11111111111111177777777777777<!>)
 }
diff --git a/compiler/testData/diagnostics/tests/override/MissingDelegate.kt b/compiler/testData/diagnostics/tests/override/MissingDelegate.kt
index 0411f893a24..11a1b422b4d 100644
--- a/compiler/testData/diagnostics/tests/override/MissingDelegate.kt
+++ b/compiler/testData/diagnostics/tests/override/MissingDelegate.kt
@@ -1,3 +1,3 @@
-class C : <!UNRESOLVED_REFERENCE, DELEGATION_NOT_TO_INTERFACE!>Base1<!> by <!UNRESOLVED_REFERENCE!>Base2<!>(1) {
+class C : <!DELEGATION_NOT_TO_INTERFACE, UNRESOLVED_REFERENCE!>Base1<!> by <!UNRESOLVED_REFERENCE!>Base2<!>(1) {
   fun test() { }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt b/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt
index fae82e55ad3..e500fde68b2 100644
--- a/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt
+++ b/compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt
@@ -11,4 +11,4 @@ interface C {
 }
 
 // TODO DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES reported twice
-<!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
+<!DIFFERENT_NAMES_FOR_THE_SAME_PARAMETER_IN_SUPERTYPES, MULTIPLE_DEFAULTS_INHERITED_FROM_SUPERTYPES_WHEN_NO_EXPLICIT_OVERRIDE!>class Z<!> : A, B(), C
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt b/compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt
index 523d8d4b97f..e18871edaae 100644
--- a/compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt
+++ b/compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt
@@ -10,4 +10,4 @@ object Impl : D, E {
     override fun foo() {}
 }
 
-val obj: D = <!MANY_IMPL_MEMBER_NOT_IMPLEMENTED, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>object<!> : D by Impl, E by Impl {}
\ No newline at end of file
+val obj: D = <!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>object<!> : D by Impl, E by Impl {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt b/compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt
index 75fd18a1ed8..d2e62a5b314 100644
--- a/compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt
+++ b/compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt
@@ -19,7 +19,7 @@ interface IDerived : ILeft, IRight {
 }
 
 // Error: ILeft::copy and IRight::copy have unrelated return types
-<!RETURN_TYPE_MISMATCH_ON_INHERITANCE, ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class CDerivedInvalid1<!> : ILeft, IRight
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED, RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class CDerivedInvalid1<!> : ILeft, IRight
 
 // Error: CLeft::copy and IRight::copy have unrelated return types
 <!RETURN_TYPE_MISMATCH_ON_INHERITANCE!>class CDerivedInvalid2<!> : CLeft(), IRight
diff --git a/compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt b/compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt
index 7a7e03f21a2..7cc85c1179a 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt
@@ -10,7 +10,7 @@ public class A {
 
 fun main(a: A, ml: Any) {
     if (ml is <!CANNOT_CHECK_FOR_ERASED!>MutableList<String><!>) {
-        a.foo(<!JAVA_TYPE_MISMATCH, DEBUG_INFO_SMARTCAST!>ml<!>)
+        a.foo(<!DEBUG_INFO_SMARTCAST, JAVA_TYPE_MISMATCH!>ml<!>)
         a.foo(ml <!UNCHECKED_CAST!>as List<Any><!>)
     }
 }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt
index c04b26a0a7a..a6b574a0b63 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt
@@ -46,7 +46,7 @@ fun test() {
     1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformJ
 
     platformNN <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
-    platformN <!UNSAFE_INFIX_CALL, INFIX_MODIFIER_REQUIRED!>plus<!> 1
+    platformN <!INFIX_MODIFIER_REQUIRED, UNSAFE_INFIX_CALL!>plus<!> 1
     platformJ <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
 
     platformNN += 1
diff --git a/compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt b/compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt
index ddb17d56242..c2cac9d5cce 100644
--- a/compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt
+++ b/compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt
@@ -17,11 +17,11 @@ class C1
 // FILE: 2.kt
 package pp
 
-@<!INVISIBLE_REFERENCE, INVISIBLE_MEMBER!>A<!>(<!INVISIBLE_MEMBER!>foo<!>)
+@<!INVISIBLE_MEMBER, INVISIBLE_REFERENCE!>A<!>(<!INVISIBLE_MEMBER!>foo<!>)
 fun f2() {}
 
-@<!INVISIBLE_REFERENCE, INVISIBLE_MEMBER!>A<!>(<!INVISIBLE_MEMBER!>foo<!>)
+@<!INVISIBLE_MEMBER, INVISIBLE_REFERENCE!>A<!>(<!INVISIBLE_MEMBER!>foo<!>)
 val p2 = ""
 
-@<!INVISIBLE_REFERENCE, INVISIBLE_MEMBER!>A<!>(<!INVISIBLE_MEMBER!>foo<!>)
+@<!INVISIBLE_MEMBER, INVISIBLE_REFERENCE!>A<!>(<!INVISIBLE_MEMBER!>foo<!>)
 class C2
diff --git a/compiler/testData/diagnostics/tests/privateInFile/visibility.kt b/compiler/testData/diagnostics/tests/privateInFile/visibility.kt
index 3659d6217b7..5ada8b96872 100644
--- a/compiler/testData/diagnostics/tests/privateInFile/visibility.kt
+++ b/compiler/testData/diagnostics/tests/privateInFile/visibility.kt
@@ -43,7 +43,7 @@ fun test() {
     <!INVISIBLE_SETTER(xx; private; file)!>xx<!> = 40
 }
 
-class B : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_REFERENCE(A; private; file), INVISIBLE_MEMBER(A; private; file)!>A<!>()<!> {}
+class B : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_MEMBER(A; private; file), INVISIBLE_REFERENCE(A; private; file)!>A<!>()<!> {}
 
 class Q {
     class W {
diff --git a/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt b/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt
index 2074c1a18ca..a3eb5de641b 100644
--- a/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt
+++ b/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt
@@ -2,7 +2,7 @@
 
 package<!SYNTAX!><!>
 
-<!FUNCTION_DECLARATION_WITH_NO_NAME, CONFLICTING_OVERLOADS!>fun ()<!> {
+<!CONFLICTING_OVERLOADS, FUNCTION_DECLARATION_WITH_NO_NAME!>fun ()<!> {
 
 }
 
diff --git a/compiler/testData/diagnostics/tests/regressions/Jet81.kt b/compiler/testData/diagnostics/tests/regressions/Jet81.kt
index 7e127490b1d..ec2e379b22b 100644
--- a/compiler/testData/diagnostics/tests/regressions/Jet81.kt
+++ b/compiler/testData/diagnostics/tests/regressions/Jet81.kt
@@ -18,9 +18,9 @@ object A {
 class Test2 {
   private val a = object {
     init {
-      <!UNINITIALIZED_VARIABLE, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1
+      <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNINITIALIZED_VARIABLE!>b<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1
     }
-    val x = <!UNINITIALIZED_VARIABLE, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
+    val x = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNINITIALIZED_VARIABLE!>b<!>
     val y = 1
   }
 
diff --git a/compiler/testData/diagnostics/tests/regressions/kt10843.kt b/compiler/testData/diagnostics/tests/regressions/kt10843.kt
index a3968e8f13c..02061727110 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt10843.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt10843.kt
@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 // See EA-76890 / KT-10843: NPE during analysis
-fun lambda(x : Int?) = x?.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER, FUNCTION_CALL_EXPECTED, NO_VALUE_FOR_PARAMETER!>let<!> <!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>l<!> {
+fun lambda(x : Int?) = x?.<!FUNCTION_CALL_EXPECTED, NO_VALUE_FOR_PARAMETER, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>let<!> <!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>l<!> {
     <!OI;CANNOT_INFER_PARAMETER_TYPE!>y<!> ->
     if (<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!> <!NI;UNREACHABLE_CODE!><!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0<!>) <!NI;UNREACHABLE_CODE!>return<!UNRESOLVED_REFERENCE!>@l<!> x<!>
     <!NI;UNREACHABLE_CODE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
diff --git a/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt b/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt
index 26ffabc8697..138ca4f7441 100644
--- a/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt
+++ b/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt
@@ -32,8 +32,8 @@ fun testY() {
 
 fun test(x: X) {
     val interface_as_fun = x.<!RESOLUTION_TO_CLASSIFIER!>A<!>()
-    val interface_as_val = x.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>A<!>
+    val interface_as_val = x.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>A<!>
 
     val object_as_fun = x.<!RESOLUTION_TO_CLASSIFIER!>B<!>()
-    val class_as_val = x.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>C<!>
+    val class_as_val = x.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>C<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt b/compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt
index 9ccebc9d19b..58c3952aef6 100644
--- a/compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt
+++ b/compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt
@@ -2,7 +2,7 @@
 
 interface I<F, G, H>
 
-class A(impl: Interface) : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE, DELEGATION_NOT_TO_INTERFACE!>Interface<!> by impl, <!UNRESOLVED_REFERENCE!>Inner<!>, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>, <!UNRESOLVED_REFERENCE!>Inner<!>> {
+class A(impl: Interface) : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!DELEGATION_NOT_TO_INTERFACE, UNRESOLVED_REFERENCE!>Interface<!> by impl, <!UNRESOLVED_REFERENCE!>Inner<!>, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>, <!UNRESOLVED_REFERENCE!>Inner<!>> {
 
     class Nested
 
diff --git a/compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt b/compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt
index 7feba245f29..7a5e2c3fe17 100644
--- a/compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt
+++ b/compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt
@@ -7,7 +7,7 @@ val bImpl: B.Companion.Interface
     get() = null!!
 
 interface A {
-    companion object : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE, DELEGATION_NOT_TO_INTERFACE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
+    companion object : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!DELEGATION_NOT_TO_INTERFACE, UNRESOLVED_REFERENCE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
 
         class Nested
 
@@ -16,7 +16,7 @@ interface A {
 }
 
 class B {
-    companion object : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE, DELEGATION_NOT_TO_INTERFACE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
+    companion object : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!DELEGATION_NOT_TO_INTERFACE, UNRESOLVED_REFERENCE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
 
         class Nested
 
diff --git a/compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt b/compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt
index 80bc769e6b7..1fec4f2a60d 100644
--- a/compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt
+++ b/compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt
@@ -3,7 +3,7 @@ interface I<F, G>
 val aImpl: A.Interface
     get() = null!!
 
-object A : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE, DELEGATION_NOT_TO_INTERFACE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
+object A : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!DELEGATION_NOT_TO_INTERFACE, UNRESOLVED_REFERENCE!>Interface<!> by aImpl, I<<!UNRESOLVED_REFERENCE!>Nested<!>, <!UNRESOLVED_REFERENCE!>Interface<!>> {
 
     class Nested
 
diff --git a/compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt b/compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt
index ff518275169..d8b38e0def1 100644
--- a/compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt
+++ b/compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt
@@ -2,7 +2,7 @@
 
 package i
 
-val <T> List<T>.length = <!UNRESOLVED_REFERENCE, EXTENSION_PROPERTY_WITH_BACKING_FIELD!>size<!>
+val <T> List<T>.length = <!EXTENSION_PROPERTY_WITH_BACKING_FIELD, UNRESOLVED_REFERENCE!>size<!>
 
 val <T> List<T>.length1 : Int get() = size
 
@@ -15,7 +15,7 @@ class A {
     val ii : Int = 1
 }
 
-val A.foo = <!UNRESOLVED_REFERENCE, EXTENSION_PROPERTY_WITH_BACKING_FIELD!>ii<!>
+val A.foo = <!EXTENSION_PROPERTY_WITH_BACKING_FIELD, UNRESOLVED_REFERENCE!>ii<!>
 
 val A.foo1 : Int get() = ii
 
diff --git a/compiler/testData/diagnostics/tests/scopes/visibility2.kt b/compiler/testData/diagnostics/tests/scopes/visibility2.kt
index ae14c01d8e2..e43e13ad56d 100644
--- a/compiler/testData/diagnostics/tests/scopes/visibility2.kt
+++ b/compiler/testData/diagnostics/tests/scopes/visibility2.kt
@@ -33,7 +33,7 @@ fun test() {
     val po = <!INVISIBLE_MEMBER(PO; private; file)!>PO<!>
 }
 
-class B : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_REFERENCE(A; private; file), INVISIBLE_MEMBER(A; private; file)!>A<!>()<!> {}
+class B : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_MEMBER(A; private; file), INVISIBLE_REFERENCE(A; private; file)!>A<!>()<!> {}
 
 class Q {
     class W {
diff --git a/compiler/testData/diagnostics/tests/scopes/visibility3.kt b/compiler/testData/diagnostics/tests/scopes/visibility3.kt
index 637a56d2103..1cded275107 100644
--- a/compiler/testData/diagnostics/tests/scopes/visibility3.kt
+++ b/compiler/testData/diagnostics/tests/scopes/visibility3.kt
@@ -36,7 +36,7 @@ fun test() {
     val po = <!INVISIBLE_MEMBER(PO; private; file)!>PO<!>
 }
 
-class B : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_REFERENCE(A; private; file), INVISIBLE_MEMBER(A; private; file)!>A<!>()<!> {}
+class B : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_MEMBER(A; private; file), INVISIBLE_REFERENCE(A; private; file)!>A<!>()<!> {}
 
 class Q {
     class W {
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt
index 0fd72e3965a..5beb17378df 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt
@@ -7,7 +7,7 @@ data class A2(val y: String, val z: Int) {
     constructor(x: String): this(x, 0)
 }
 
-data class <!PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS, DATA_CLASS_WITHOUT_PARAMETERS!>A3<!> {
+data class <!DATA_CLASS_WITHOUT_PARAMETERS, PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS!>A3<!> {
     constructor()
 }
 
diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt b/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt
index 2c178995e25..c785e34077e 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt
@@ -16,7 +16,7 @@ val foo: Foo = run {
 val foofoo: Foo = <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>run<!> {
     val x = foo()
     if (x == null) throw Exception()
-    <!NI;TYPE_MISMATCH, DEBUG_INFO_SMARTCAST!>x<!>
+    <!DEBUG_INFO_SMARTCAST, NI;TYPE_MISMATCH!>x<!>
 }
 
 val bar: Bar = <!NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>run<!> {
diff --git a/compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyBefore.kt b/compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyBefore.kt
index 1eddc3a2138..a13c23e9b0f 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyBefore.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyBefore.kt
@@ -10,6 +10,6 @@ fun failsWithClassCastException() {
     val sometimesNotInt: Any? by AlternatingDelegate()
 
     if (sometimesNotInt is Int) {
-        <!DEPRECATED_SMARTCAST, DEBUG_INFO_SMARTCAST!>sometimesNotInt<!>.inc()
+        <!DEBUG_INFO_SMARTCAST, DEPRECATED_SMARTCAST!>sometimesNotInt<!>.inc()
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt b/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt
index 737e62dc318..6579e10bc71 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt
@@ -2,7 +2,7 @@ sealed class My(open val x: Int?) {
     init {
         if (<!DEBUG_INFO_LEAKING_THIS!>x<!> != null) {
             // Should be error: property is open
-            <!SMARTCAST_IMPOSSIBLE, DEBUG_INFO_LEAKING_THIS!>x<!>.hashCode()
+            <!DEBUG_INFO_LEAKING_THIS, SMARTCAST_IMPOSSIBLE!>x<!>.hashCode()
         }
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt b/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt
index 42042412e0f..8819464426b 100644
--- a/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt
+++ b/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt
@@ -6,6 +6,6 @@ annotation class Anno1(val s: String)
 annotation class Anno2 @SinceKotlin("1.1") constructor()
 
 
-@<!UNRESOLVED_REFERENCE, API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>Anno1<!>("")
-@<!UNRESOLVED_REFERENCE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>Anno2<!>
+@<!API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>Anno1<!>("")
+@<!DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>Anno2<!>
 fun t1() {}
diff --git a/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt b/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt
index a07ffd00087..28fc97bdf05 100644
--- a/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt
+++ b/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt
@@ -14,7 +14,7 @@ class Quux @SinceKotlin("1.0") constructor()
 fun t1(): <!API_NOT_AVAILABLE!>Foo<!> = <!UNRESOLVED_REFERENCE!>Foo<!>()
 
 // TODO: do not report API_NOT_AVAILABLE twice
-fun t2() = object : <!UNRESOLVED_REFERENCE, API_NOT_AVAILABLE, API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>Foo<!>() {}
+fun t2() = object : <!API_NOT_AVAILABLE, API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>Foo<!>() {}
 
 fun t3(): Bar? = <!UNRESOLVED_REFERENCE!>Bar<!>()
 
diff --git a/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt b/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt
index 05e60f83797..6c8608a99f1 100644
--- a/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt
+++ b/compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt
@@ -15,6 +15,6 @@ typealias C2_Alias = C2
 val test1 = <!UNRESOLVED_REFERENCE!>C1_Alias<!>()
 val test2 = C2_Alias(<!NO_VALUE_FOR_PARAMETER!>)<!>
 
-class Test3 : <!UNRESOLVED_REFERENCE, API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET!>C1_Alias<!>()
+class Test3 : <!API_NOT_AVAILABLE, DEBUG_INFO_UNRESOLVED_WITH_TARGET, UNRESOLVED_REFERENCE!>C1_Alias<!>()
 
 class Test4 : C2_Alias(<!NO_VALUE_FOR_PARAMETER!>)<!>
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt b/compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt
index f6701593bc8..66325240ee1 100644
--- a/compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt
+++ b/compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt
@@ -6,5 +6,5 @@ interface Foo<!CONSTRUCTOR_IN_INTERFACE!>()<!> : <!INTERFACE_WITH_SUPERCLASS!>ba
 interface Foo2 : <!INTERFACE_WITH_SUPERCLASS!>bar<!>, Foo {
 }
 
-open class Foo1() : bar(), <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!>() {}
-open class Foo12 : bar(), <!SUPERTYPE_NOT_INITIALIZED, MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE!>bar<!> {}
\ No newline at end of file
+open class Foo1() : bar(), <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE, SUPERTYPE_NOT_INITIALIZED!>bar<!>, Foo, <!SUPERTYPE_APPEARS_TWICE!>Foo<!>() {}
+open class Foo12 : bar(), <!MANY_CLASSES_IN_SUPERTYPE_LIST, SUPERTYPE_APPEARS_TWICE, SUPERTYPE_NOT_INITIALIZED!>bar<!> {}
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt b/compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt
index 01347eb583a..83ea2ee4db9 100644
--- a/compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt
+++ b/compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt
@@ -1,6 +1,6 @@
 class Foo<<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>T : Cloneable<!>> where T : Comparable<T> {
     fun <<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>U : Cloneable<!>> foo(u: U): U where U: Comparable<U> {
-        fun <<!MISPLACED_TYPE_PARAMETER_CONSTRAINTS, BOUNDS_NOT_ALLOWED_IF_BOUNDED_BY_TYPE_PARAMETER!>T: Any<!>> bar() where T: U {}
+        fun <<!BOUNDS_NOT_ALLOWED_IF_BOUNDED_BY_TYPE_PARAMETER, MISPLACED_TYPE_PARAMETER_CONSTRAINTS!>T: Any<!>> bar() where T: U {}
         return u
     }
 
diff --git a/compiler/testData/diagnostics/tests/typealias/kt14641.kt b/compiler/testData/diagnostics/tests/typealias/kt14641.kt
index 19cce4033ae..cc95788fb9e 100644
--- a/compiler/testData/diagnostics/tests/typealias/kt14641.kt
+++ b/compiler/testData/diagnostics/tests/typealias/kt14641.kt
@@ -7,5 +7,5 @@ class A {
 
 fun f() {
     val a = A()
-    a.<!NO_COMPANION_OBJECT, NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE!>BAlias<!>
+    a.<!NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, NO_COMPANION_OBJECT!>BAlias<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt
index 5e7c55d1075..0f28a885684 100644
--- a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt
+++ b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt
@@ -30,9 +30,9 @@ fun baz(s: String) {}
 fun getArr(): Array<String>? = null
 
 fun f() {
-    A().foo(1, <!SPREAD_OF_NULLABLE!>*<!>args)
-    bar(2, <!SPREAD_OF_NULLABLE!>*<!><!TYPE_MISMATCH!>args<!>)
-    baz(<!NON_VARARG_SPREAD, SPREAD_OF_NULLABLE!>*<!><!NI;TYPE_MISMATCH!>args<!>)
+    A().foo(1, <!OI;SPREAD_OF_NULLABLE!>*<!>args)
+    bar(2, <!OI;SPREAD_OF_NULLABLE!>*<!><!TYPE_MISMATCH!>args<!>)
+    baz(<!NON_VARARG_SPREAD, OI;SPREAD_OF_NULLABLE!>*<!><!NI;TYPE_MISMATCH!>args<!>)
 }
 
 fun g(args: Array<String>?) {
diff --git a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt
index 9af27d5e84b..07d6b5ad40e 100644
--- a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt
@@ -19,7 +19,7 @@ fun foo3() {}
 @Anno(value = <!ANNOTATION_ARGUMENT_IS_NON_CONST!>[<!ANNOTATION_ARGUMENT_IS_NON_CONST!>nonConstLong()<!>]<!>)
 fun foo4() {}
 
-@Anno(value = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, ANNOTATION_ARGUMENT_MUST_BE_CONST!>nonConstArray<!>)
+@Anno(value = *<!ANNOTATION_ARGUMENT_MUST_BE_CONST, REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>nonConstArray<!>)
 fun bar1() {}
 
 @Anno(*<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>nonConstArray<!>)
diff --git a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt
index 87efd2baa86..8ebd09ff23b 100644
--- a/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt
@@ -19,7 +19,7 @@ fun foo3() {}
 @Anno(value = <!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>[<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>nonConstLong()<!>]<!>)
 fun foo4() {}
 
-@Anno(value = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, ANNOTATION_ARGUMENT_MUST_BE_CONST!>nonConstArray<!>)
+@Anno(value = *<!ANNOTATION_ARGUMENT_MUST_BE_CONST, REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>nonConstArray<!>)
 fun bar1() {}
 
 @Anno(*<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>nonConstArray<!>)
diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt
index 2144350eca1..ec508182b04 100644
--- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt
@@ -8,9 +8,9 @@ open class Cls(vararg p: Long)
 
 fun test(i: IntArray) {
     foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>1<!>)
-    foo(s = <!TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>i<!>)
+    foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>i<!>)
     foo(s = *i)
-    foo(s = <!TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>intArrayOf(1)<!>)
+    foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>intArrayOf(1)<!>)
     foo(s = *intArrayOf(1))
     foo(1)
 
diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt
index 3ec91aa8778..7c06def21f5 100644
--- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt
+++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt
@@ -8,9 +8,9 @@ open class Cls(vararg p: Long)
 
 fun test(i: IntArray) {
     foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>1<!>)
-    foo(s = <!TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>i<!>)
+    foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, TYPE_MISMATCH!>i<!>)
     foo(s = *i)
-    foo(s = <!TYPE_MISMATCH, ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION!>intArrayOf(1)<!>)
+    foo(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, TYPE_MISMATCH!>intArrayOf(1)<!>)
     foo(s = *intArrayOf(1))
     foo(1)
 
diff --git a/compiler/testData/diagnostics/tests/when/When.kt b/compiler/testData/diagnostics/tests/when/When.kt
index 177fcaa3804..67d028da910 100644
--- a/compiler/testData/diagnostics/tests/when/When.kt
+++ b/compiler/testData/diagnostics/tests/when/When.kt
@@ -28,7 +28,7 @@ fun test() {
 
   when (x) {
     <!INCOMPATIBLE_TYPES!>s<!> -> <!UNUSED_EXPRESSION!>1<!>
-    <!INCOMPATIBLE_TYPES, DUPLICATE_LABEL_IN_WHEN!>""<!> -> <!UNUSED_EXPRESSION!>1<!>
+    <!DUPLICATE_LABEL_IN_WHEN, INCOMPATIBLE_TYPES!>""<!> -> <!UNUSED_EXPRESSION!>1<!>
     x -> <!UNUSED_EXPRESSION!>1<!>
     1 -> <!UNUSED_EXPRESSION!>1<!>
   }
diff --git a/compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedVariableDeclarationsInWhenSubject.kt b/compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedVariableDeclarationsInWhenSubject.kt
index 21c8ca8bbf5..0fc506ca558 100644
--- a/compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedVariableDeclarationsInWhenSubject.kt
+++ b/compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedVariableDeclarationsInWhenSubject.kt
@@ -13,7 +13,7 @@ fun testSimpleValInWhenSubject() {
 
 fun testValWithoutInitializerWhenSubject() {
     when (<!ILLEGAL_DECLARATION_IN_WHEN_SUBJECT!>val y: Any<!>) {
-        is String -> <!UNINITIALIZED_VARIABLE, DEBUG_INFO_SMARTCAST!>y<!>.length
+        is String -> <!DEBUG_INFO_SMARTCAST, UNINITIALIZED_VARIABLE!>y<!>.length
     }
 }
 
diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.kt
index f568074361a..ba786a14249 100644
--- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.kt
+++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.kt
@@ -15,9 +15,9 @@ fun test(d: Any, dl: Collection<dynamic>) {
 
     when (d) {
         <!USELESS_IS_CHECK!>is <!DYNAMIC_NOT_ALLOWED!>dynamic<!><!> -> {}
-        <!USELESS_IS_CHECK!>is <!DYNAMIC_NOT_ALLOWED, DUPLICATE_LABEL_IN_WHEN!>dynamic?<!><!> -> {}
+        <!USELESS_IS_CHECK!>is <!DUPLICATE_LABEL_IN_WHEN, DYNAMIC_NOT_ALLOWED!>dynamic?<!><!> -> {}
         <!USELESS_IS_CHECK!>!is <!DYNAMIC_NOT_ALLOWED!>dynamic<!><!> -> {}
-        <!USELESS_IS_CHECK!>!is <!DYNAMIC_NOT_ALLOWED, DUPLICATE_LABEL_IN_WHEN!>dynamic?<!><!> -> {}
+        <!USELESS_IS_CHECK!>!is <!DUPLICATE_LABEL_IN_WHEN, DYNAMIC_NOT_ALLOWED!>dynamic?<!><!> -> {}
     }
 
     dl as List<dynamic>
diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/jsCode/argumentIsLiteral.kt b/compiler/testData/diagnostics/testsWithJsStdLib/jsCode/argumentIsLiteral.kt
index 0a93b0e54c1..a66646c4d9c 100644
--- a/compiler/testData/diagnostics/testsWithJsStdLib/jsCode/argumentIsLiteral.kt
+++ b/compiler/testData/diagnostics/testsWithJsStdLib/jsCode/argumentIsLiteral.kt
@@ -9,7 +9,7 @@ fun test() {
     js((b))
     js(("c"))
     js(<!CONSTANT_EXPECTED_TYPE_MISMATCH, JSCODE_ARGUMENT_SHOULD_BE_CONSTANT!>3<!>)
-    js(<!TYPE_MISMATCH, JSCODE_ARGUMENT_SHOULD_BE_CONSTANT!>3 + 2<!>)
+    js(<!JSCODE_ARGUMENT_SHOULD_BE_CONSTANT, TYPE_MISMATCH!>3 + 2<!>)
     js(<!CONSTANT_EXPECTED_TYPE_MISMATCH, JSCODE_ARGUMENT_SHOULD_BE_CONSTANT!>1.0f<!>)
     js(<!CONSTANT_EXPECTED_TYPE_MISMATCH, JSCODE_ARGUMENT_SHOULD_BE_CONSTANT!>true<!>)
     js("$a")
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt
index 98c74373c3a..8dca3f86c86 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt
@@ -6,7 +6,7 @@ annotation class Ann(val i: IntArray)
 @Ann(intArrayOf(i2))
 @Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
 @Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!TYPE_MISMATCH, NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)<!>)
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION, TYPE_MISMATCH!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)<!>)
 class Test
 
 var i = 1
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt
index f810078dfd2..9e4899ad988 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt
@@ -4,6 +4,6 @@ class A
 <!EXPLICIT_METADATA_IS_DISALLOWED!>@Metadata(extraString = "_")<!>
 annotation class B(val m: Metadata)
 
-<!WRONG_ANNOTATION_TARGET, EXPLICIT_METADATA_IS_DISALLOWED!>@Metadata(extraInt = 0)<!>
+<!EXPLICIT_METADATA_IS_DISALLOWED, WRONG_ANNOTATION_TARGET!>@Metadata(extraInt = 0)<!>
 @B(Metadata())
 fun f() {}
diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_16.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_16.kt
index c19161af4a5..15b17fc94ef 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_16.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_16.kt
@@ -6,36 +6,36 @@ interface B {
 
         }
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic private fun a2()<!> {
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic private fun a2()<!> {
 
         }
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic protected fun a3()<!> {
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic protected fun a3()<!> {
 
         }
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic internal fun a4()<!> {
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic internal fun a4()<!> {
 
         }
 
         <!JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
         var foo<!> = 1
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic
         var foo1<!> = 1
             protected set
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic
         var foo2<!> = 1
             private set
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic
         private var foo3<!> = 1
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic
         protected var foo4<!> = 1
 
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic
         protected var foo5<!> = 1
 
         <!JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic
@@ -48,7 +48,7 @@ interface B {
         <!JVM_STATIC_IN_INTERFACE_1_6!><!ANNOTATION_TARGETS_NON_EXISTENT_ACCESSOR!>@JvmStatic<!> <!SETTER_VISIBILITY_INCONSISTENT_WITH_PROPERTY_VISIBILITY!>public<!> set<!>
 
         public var foo9 = 1
-        <!JVM_STATIC_ON_NON_PUBLIC_MEMBER, JVM_STATIC_IN_INTERFACE_1_6!>@JvmStatic private set<!>
+        <!JVM_STATIC_IN_INTERFACE_1_6, JVM_STATIC_ON_NON_PUBLIC_MEMBER!>@JvmStatic private set<!>
 
     }
 
diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
index a058c970516..41d193eb683 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt
@@ -43,7 +43,7 @@ fun foo() {
     <!NI;UNREACHABLE_CODE!>val s: String = manyArgumentsBuilder({}, { "" }) { 1 }<!>
 
     <!NI;UNREACHABLE_CODE!>manyArgumentsBuilder<String>({}, { "" }, { 1 })<!>
-    <!NI;UNREACHABLE_CODE!>manyArgumentsBuilder<String>({}, { <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })<!>
+    <!NI;UNREACHABLE_CODE!>manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })<!>
 
     <!NI;UNREACHABLE_CODE!>severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
         x checkType { _<String>() }
diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/trait.kt b/compiler/testData/diagnostics/testsWithStdLib/native/trait.kt
index d0c3622c48e..608f7ccb47e 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/native/trait.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/native/trait.kt
@@ -2,7 +2,7 @@ import kotlin.jvm.*
 
 interface Tr {
     <!EXTERNAL_DECLARATION_IN_INTERFACE!>external fun foo()<!>
-    <!EXTERNAL_DECLARATION_IN_INTERFACE, EXTERNAL_DECLARATION_CANNOT_HAVE_BODY!>external fun bar()<!> {}
+    <!EXTERNAL_DECLARATION_CANNOT_HAVE_BODY, EXTERNAL_DECLARATION_IN_INTERFACE!>external fun bar()<!> {}
 
     companion object {
         external fun foo()
diff --git a/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt b/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt
index be4b0fbc813..a52ba8b27fe 100644
--- a/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt
+++ b/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt
@@ -6,7 +6,7 @@ inline fun<reified T> foo(block: () -> T): String = block().toString()
 inline fun <reified T: Any> javaClass(): Class<T> = T::class.java
 
 fun box() {
-    val a = <!OI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, OI;UNSUPPORTED!>arrayOf<!>(null!!)
+    val a = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, UNSUPPORTED!>arrayOf<!>(null!!)
     val b = <!UNSUPPORTED!>Array<!><<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Nothing?<!>>(5) { null!! }
     val c = <!OI;REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!>() { null!! }
     val d = foo<Any> { null!! }
diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt b/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt
index 0bf938b9b4b..de61b569c7d 100644
--- a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt
+++ b/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt
@@ -33,7 +33,7 @@ fun test() {
     takeUInt(<!INTEGER_OVERFLOW, TYPE_MISMATCH!>Int.MAX_VALUE * 2<!>)
     takeUInt(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>4294967294<!>)
 
-    takeUBytes(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>2<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>255<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED, CONSTANT_EXPECTED_TYPE_MISMATCH!>256<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>0<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED, TYPE_MISMATCH!>-1<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>40 + 2<!>)
+    takeUBytes(<!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>1<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>2<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>255<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH, SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>256<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>0<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED, TYPE_MISMATCH!>-1<!>, <!SIGNED_CONSTANT_CONVERTED_TO_UNSIGNED!>40 + 2<!>)
 
     takeUInt(<!TYPE_MISMATCH!>1.myPlus(2)<!>)
 
diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt b/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt
index d999c260541..664392a7bb0 100644
--- a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt
+++ b/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt
@@ -11,7 +11,7 @@ package a
 import p.<!INVISIBLE_REFERENCE!>Foo<!>
 import p.<!INVISIBLE_REFERENCE!>Foo<!>.Nested
 
-class Bar : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_REFERENCE, INVISIBLE_MEMBER!>Foo<!>()<!> {
+class Bar : <!EXPOSED_SUPER_CLASS!><!INVISIBLE_MEMBER, INVISIBLE_REFERENCE!>Foo<!>()<!> {
     protected fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(): <!INVISIBLE_REFERENCE!>Nested<!>? = null
 }
 
diff --git a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.1.kt b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.1.kt
index 7a9e8003559..5d805129134 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.1.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.1.kt
@@ -48,7 +48,7 @@ val value_12 = <!FLOAT_LITERAL_OUT_OF_RANGE!>.8____88888888888888888888888888888
 val value_13 = <!FLOAT_LITERAL_OUT_OF_RANGE!>0_0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000_0eF<!>
 
 // TESTCASE NUMBER: 14
-val value_14 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_e-f<!>
+val value_14 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_e-f<!>
 
 // TESTCASE NUMBER: 15
 val value_15 = <!FLOAT_LITERAL_OUT_OF_RANGE!>.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e+<!>
diff --git a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.2.kt b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.2.kt
index 9df5061cab7..364f7abef9f 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.2.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/1.2.kt
@@ -27,7 +27,7 @@ val value_5 = <!ILLEGAL_UNDERSCORE!>0_00e1_<!>
 val value_6 = <!ILLEGAL_UNDERSCORE!>.0_0__0___0E0_______________<!>
 
 // TESTCASE NUMBER: 7
-val value_7 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>0_1e+100_____f<!>
+val value_7 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>0_1e+100_____f<!>
 
 // TESTCASE NUMBER: 8
 val value_8 = <!ILLEGAL_UNDERSCORE!>.0_0E-0001___<!>
@@ -39,7 +39,7 @@ val value_9 = <!ILLEGAL_UNDERSCORE!>0___0__0e4___<!>
 val value_10 = <!ILLEGAL_UNDERSCORE!>0_00_0e99_f<!>
 
 // TESTCASE NUMBER: 11
-val value_11 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_ZERO!>.0_5E-93_______F<!>
+val value_11 = <!FLOAT_LITERAL_CONFORMS_ZERO, ILLEGAL_UNDERSCORE!>.0_5E-93_______F<!>
 
 // TESTCASE NUMBER: 12
 val value_12 = <!ILLEGAL_UNDERSCORE!>.8____8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888_____8888888888888888888e+5_f<!>
diff --git a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.1.kt b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.1.kt
index a03af350224..6b9a5e1a891 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.1.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.1.kt
@@ -24,7 +24,7 @@ val value_4 = <!ILLEGAL_UNDERSCORE!>0__0.0_____e0f<!>
 val value_5 = <!ILLEGAL_UNDERSCORE!>9_______9______9_____9____9___9__9_9.0___E-1<!>
 
 // TESTCASE NUMBER: 6
-val value_6 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>0_0_0_0_0_0_0_0_0_0.12345678___e+90F<!>
+val value_6 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>0_0_0_0_0_0_0_0_0_0.12345678___e+90F<!>
 
 // TESTCASE NUMBER: 7
 val value_7 = <!ILLEGAL_UNDERSCORE!>1_2_3_4_5_6_7_8_9.2_3_4_5_6_7_8_9_e-0<!>
@@ -39,7 +39,7 @@ val value_9 = <!ILLEGAL_UNDERSCORE!>5.6_0_E+05F<!>
 val value_10 = <!ILLEGAL_UNDERSCORE!>6_54.76_5__e-4<!>
 
 // TESTCASE NUMBER: 11
-val value_11 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_ZERO!>9_____________87654321.0__e-9_8765432_____________1F<!>
+val value_11 = <!FLOAT_LITERAL_CONFORMS_ZERO, ILLEGAL_UNDERSCORE!>9_____________87654321.0__e-9_8765432_____________1F<!>
 
 // TESTCASE NUMBER: 12
 val value_12 = <!ILLEGAL_UNDERSCORE!>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000___0.000000000000000000000000_e000000000000000000000000000000000000000000000000000000000000000_0F<!>
@@ -48,4 +48,4 @@ val value_12 = <!ILLEGAL_UNDERSCORE!>0000000000000000000000000000000000000000000
 val value_13 = <!ILLEGAL_UNDERSCORE!>0_000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0____E-0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000<!>
 
 // TESTCASE NUMBER: 14
-val value_14 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>9999999999999999999999999999999999999999999_______________999999999999999999999999999999999999999999999.33333333333333333333333333333333333333333333333_333333333333333333333333333333333333333_e3_3f<!>
+val value_14 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>9999999999999999999999999999999999999999999_______________999999999999999999999999999999999999999999999.33333333333333333333333333333333333333333333333_333333333333333333333333333333333333333_e3_3f<!>
diff --git a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.2.kt b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.2.kt
index 30ac508143a..ff6a35af7ef 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.2.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.2.kt
@@ -27,10 +27,10 @@ val value_5 = <!ILLEGAL_UNDERSCORE!>1E-_2F<!>
 val value_6 = <!ILLEGAL_UNDERSCORE!>3e+_0f<!>
 
 // TESTCASE NUMBER: 7
-val value_7 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>5E_<!>-0
+val value_7 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>5E_<!>-0
 
 // TESTCASE NUMBER: 8
-val value_8 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>5e_<!>-0F
+val value_8 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>5e_<!>-0F
 
 // TESTCASE NUMBER: 9
 val value_9 = <!ILLEGAL_UNDERSCORE!>5e_00000000<!>
@@ -39,7 +39,7 @@ val value_9 = <!ILLEGAL_UNDERSCORE!>5e_00000000<!>
 val value_10 = <!ILLEGAL_UNDERSCORE!>0.0_0e_1_0f<!>
 
 // TESTCASE NUMBER: 11
-val value_11 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>0.0_0E____<!>-0__0_0F
+val value_11 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>0.0_0E____<!>-0__0_0F
 
 // TESTCASE NUMBER: 12
 val value_12 = <!ILLEGAL_UNDERSCORE!>.0_0E__0_0<!>
@@ -63,16 +63,16 @@ val value_17 = <!ILLEGAL_UNDERSCORE!>666_666.0__________________________________
 val value_18 = <!ILLEGAL_UNDERSCORE!>8888888_8.000e_____0f<!>
 
 // TESTCASE NUMBER: 19
-val value_19 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>9_______9______9_____9____9___9__9_9.0E__<!>-1
+val value_19 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>9_______9______9_____9____9___9__9_9.0E__<!>-1
 
 // TESTCASE NUMBER: 20
-val value_20 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>0_0_0_0_0_0_0_0_0_0.12345678e+__90F<!>
+val value_20 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>0_0_0_0_0_0_0_0_0_0.12345678e+__90F<!>
 
 // TESTCASE NUMBER: 21
-val value_21 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>1_2_3_4_5_6_7_8_9.2_3_4_5_6_7_8_9e_<!>-<!UNRESOLVED_REFERENCE!>_0<!>
+val value_21 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>1_2_3_4_5_6_7_8_9.2_3_4_5_6_7_8_9e_<!>-<!UNRESOLVED_REFERENCE!>_0<!>
 
 // TESTCASE NUMBER: 22
-val value_22 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>.345______________6e_____7_______8f<!>
+val value_22 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>.345______________6e_____7_______8f<!>
 
 // TESTCASE NUMBER: 23
 val value_23 = <!ILLEGAL_UNDERSCORE!>.45_6E_7f<!>
@@ -81,10 +81,10 @@ val value_23 = <!ILLEGAL_UNDERSCORE!>.45_6E_7f<!>
 val value_24 = <!ILLEGAL_UNDERSCORE!>6_54.765e-_4<!>
 
 // TESTCASE NUMBER: 25
-val value_25 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>7_6543.8E____7654_3<!>
+val value_25 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>7_6543.8E____7654_3<!>
 
 // TESTCASE NUMBER: 26
-val value_26 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>.9E+_______0_____________8765432f<!>
+val value_26 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>.9E+_______0_____________8765432f<!>
 
 // TESTCASE NUMBER: 27
 val value_27 = <!ILLEGAL_UNDERSCORE!>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000___0.000000000000000000000000e_000000000000000000000000000000000000000000000000000000000000000_0F<!>
@@ -93,4 +93,4 @@ val value_27 = <!ILLEGAL_UNDERSCORE!>0000000000000000000000000000000000000000000
 val value_28 = <!ILLEGAL_UNDERSCORE!>0_000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0E-_0___000000000000000000000000000000000000000000000000000000000000000000000000000000000000000<!>
 
 // TESTCASE NUMBER: 29
-val value_29 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>9999999999999999999999999999999999999999999_______________999999999999999999999999999999999999999999999.33333333333333333333333333333333333333333333333_333333333333333333333333333333333333333e___3_3f<!>
+val value_29 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>9999999999999999999999999999999999999999999_______________999999999999999999999999999999999999999999999.33333333333333333333333333333333333333333333333_333333333333333333333333333333333333333e___3_3f<!>
diff --git a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.3.kt b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.3.kt
index b2ebf30b068..8412a5c4e73 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.3.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/constant-literals/real-literals/p-4/neg/2.3.kt
@@ -21,16 +21,16 @@ val value_3 = <!ILLEGAL_UNDERSCORE!>1_E-_2F<!>
 val value_4 = <!ILLEGAL_UNDERSCORE!>3_e+_0f<!>
 
 // TESTCASE NUMBER: 5
-val value_5 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>5_E_<!>-0
+val value_5 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>5_E_<!>-0
 
 // TESTCASE NUMBER: 6
-val value_6 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>5_e_<!>-0F
+val value_6 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>5_e_<!>-0F
 
 // TESTCASE NUMBER: 7
 val value_7 = <!ILLEGAL_UNDERSCORE!>5_e_00000000<!>
 
 // TESTCASE NUMBER: 8
-val value_8 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>0.0_0___E____<!>-0__0_0F
+val value_8 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>0.0_0___E____<!>-0__0_0F
 
 // TESTCASE NUMBER: 9
 val value_9 = <!ILLEGAL_UNDERSCORE!>0__0.0_____e___0f<!>
@@ -48,19 +48,19 @@ val value_12 = <!ILLEGAL_UNDERSCORE!>33__3.0_e_10__0<!>
 val value_13 = <!ILLEGAL_UNDERSCORE!>.0_E_0______00F<!>
 
 // TESTCASE NUMBER: 14
-val value_14 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>5_________555_________5.0____e____<!>-<!UNRESOLVED_REFERENCE!>____9<!>
+val value_14 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>5_________555_________5.0____e____<!>-<!UNRESOLVED_REFERENCE!>____9<!>
 
 // TESTCASE NUMBER: 15
 val value_15 = <!ILLEGAL_UNDERSCORE!>666_666.0__________________________________________________1_E+_2___________________________________________________________________0F<!>
 
 // TESTCASE NUMBER: 16
-val value_16 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>9_______9______9_____9____9___9__9_9.0___E__<!>-1
+val value_16 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>9_______9______9_____9____9___9__9_9.0___E__<!>-1
 
 // TESTCASE NUMBER: 17
-val value_17 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>0_0_0_0_0_0_0_0_0_0.12345678___e+__90F<!>
+val value_17 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>0_0_0_0_0_0_0_0_0_0.12345678___e+__90F<!>
 
 // TESTCASE NUMBER: 18
-val value_18 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>1_2_3_4_5_6_7_8_9.2_3_4_5_6_7_8_9_e_<!>-<!UNRESOLVED_REFERENCE!>_0<!>
+val value_18 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>1_2_3_4_5_6_7_8_9.2_3_4_5_6_7_8_9_e_<!>-<!UNRESOLVED_REFERENCE!>_0<!>
 
 // TESTCASE NUMBER: 19
 val value_19 = <!ILLEGAL_UNDERSCORE!>.45_6_E_7f<!>
@@ -72,10 +72,10 @@ val value_20 = <!ILLEGAL_UNDERSCORE!>456.5__e_0_6<!>
 val value_21 = <!ILLEGAL_UNDERSCORE!>6_54.76_5_e-_4<!>
 
 // TESTCASE NUMBER: 22
-val value_22 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>7_6543.8____E____7654_3<!>
+val value_22 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>7_6543.8____E____7654_3<!>
 
 // TESTCASE NUMBER: 23
-val value_23 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_OUT_OF_RANGE!>9_____________87654321.0__e__<!>-9_8765432_____________1F
+val value_23 = <!FLOAT_LITERAL_OUT_OF_RANGE, ILLEGAL_UNDERSCORE!>9_____________87654321.0__e__<!>-9_8765432_____________1F
 
 // TESTCASE NUMBER: 24
 val value_24 = <!ILLEGAL_UNDERSCORE!>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000___0.000000000000000000000000_e_000000000000000000000000000000000000000000000000000000000000000_0F<!>
@@ -84,4 +84,4 @@ val value_24 = <!ILLEGAL_UNDERSCORE!>0000000000000000000000000000000000000000000
 val value_25 = <!ILLEGAL_UNDERSCORE!>0_000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_E-_0___000000000000000000000000000000000000000000000000000000000000000000000000000000000000000<!>
 
 // TESTCASE NUMBER: 26
-val value_26 = <!ILLEGAL_UNDERSCORE, FLOAT_LITERAL_CONFORMS_INFINITY!>9999999999999999999999999999999999999999999_______________999999999999999999999999999999999999999999999.33333333333333333333333333333333333333333333333_333333333333333333333333333333333333333_e_3_3f<!>
+val value_26 = <!FLOAT_LITERAL_CONFORMS_INFINITY, ILLEGAL_UNDERSCORE!>9999999999999999999999999999999999999999999_______________999999999999999999999999999999999999999999999.33333333333333333333333333333333333333333333333_333333333333333333333333333333333333333_e_3_3f<!>
diff --git a/compiler/tests-spec/testData/diagnostics/linked/when-expression/p-7/neg/3.2.kt b/compiler/tests-spec/testData/diagnostics/linked/when-expression/p-7/neg/3.2.kt
index 4aecb70f5d8..56b179ead2e 100644
--- a/compiler/tests-spec/testData/diagnostics/linked/when-expression/p-7/neg/3.2.kt
+++ b/compiler/tests-spec/testData/diagnostics/linked/when-expression/p-7/neg/3.2.kt
@@ -14,9 +14,9 @@
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int, value_2: _EmptyClass, value_3: Int, value_4: Any): String {
     when (value_1) {
-        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER, TYPE_MISMATCH_IN_RANGE!>in<!> value_2  -> return ""
-        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER, TYPE_MISMATCH_IN_RANGE!>in<!> value_3  -> return ""
-        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER, TYPE_MISMATCH_IN_RANGE!>in<!> value_4  -> return ""
+        <!TYPE_MISMATCH_IN_RANGE, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>in<!> value_2  -> return ""
+        <!TYPE_MISMATCH_IN_RANGE, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>in<!> value_3  -> return ""
+        <!TYPE_MISMATCH_IN_RANGE, UNRESOLVED_REFERENCE_WRONG_RECEIVER!>in<!> value_4  -> return ""
     }
 
     return ""
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.kt
index da8347ea28f..b5291aa5550 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.kt
@@ -246,7 +246,7 @@ fun case_4(value_1: Any?) {
     value_1?.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>toByte<!>()
     case_4_2(<!TYPE_MISMATCH!>value_1<!>)
     <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!>toByte()
-    case_4_3(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>value_1<!>)
+    case_4_3(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>value_1<!>)
     <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
 }
 
@@ -340,28 +340,28 @@ fun case_8(value_1: Any?) {
         value_1?.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>toByte<!>()
         if (case_8_2(<!TYPE_MISMATCH!>value_1<!>)) {
             <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!>toByte()
-            if (case_8_3(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>value_1<!>)) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
+            if (case_8_3(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>value_1<!>)) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
         }
     }
     if (!case_8_4(value_1)) {
         value_1?.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>toByte<!>()
         if (!case_8_5(<!TYPE_MISMATCH!>value_1<!>)) {
             <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!>toByte()
-            if (!case_8_6(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>value_1<!>)) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
+            if (!case_8_6(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>value_1<!>)) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
         }
     }
     if (case_8_7(value_1) == null) {
         value_1?.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>toByte<!>()
         if (case_8_8(<!TYPE_MISMATCH!>value_1<!>) != null) {
             <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!>toByte()
-            if (case_8_9(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>value_1<!>) != null) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
+            if (case_8_9(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>value_1<!>) != null) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
         }
     }
     if (case_8_10(value_1) != null) {
         value_1?.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>toByte<!>()
         if (case_8_11(<!TYPE_MISMATCH!>value_1<!>) == null) {
             <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!>toByte()
-            if (case_8_12(<!TYPE_MISMATCH, DEBUG_INFO_CONSTANT!>value_1<!>) == null) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
+            if (case_8_12(<!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>value_1<!>) == null) <!DEBUG_INFO_CONSTANT!>value_1<!><!UNSAFE_CALL!>.<!><!MISSING_DEPENDENCY_CLASS, MISSING_DEPENDENCY_CLASS!>inv<!>()
         }
     }
 }
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/8.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/8.kt
index 6b253097a6c..476bfd483aa 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/8.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/8.kt
@@ -103,7 +103,7 @@ fun case_4(value_1: Number, value_2: (() -> Unit)?) {
     } else if (contracts.case_4(value_1, value_2) == false) {
         println(value_2)
     } else if (contracts.case_4(value_1, value_2) == null) {
-        <!UNSAFE_IMPLICIT_INVOKE_CALL, DEBUG_INFO_CONSTANT!>value_2<!>()
+        <!DEBUG_INFO_CONSTANT, UNSAFE_IMPLICIT_INVOKE_CALL!>value_2<!>()
     }
 }
 
diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.kt b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.kt
index 55425c12898..931a297910b 100644
--- a/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.kt
+++ b/compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/5.kt
@@ -13,7 +13,7 @@ import kotlin.contracts.*
 
 // TESTCASE NUMBER: 1
 fun case_1(): Boolean {
-    contract { returns(true) implies (<!TYPE_MISMATCH, ERROR_IN_CONTRACT_DESCRIPTION!>-10<!>) }
+    contract { returns(true) implies (<!ERROR_IN_CONTRACT_DESCRIPTION, TYPE_MISMATCH!>-10<!>) }
     return true
 }
 
@@ -25,7 +25,7 @@ fun case_2(): Boolean {
 
 // TESTCASE NUMBER: 3
 fun case_3(): Boolean {
-    contract { returns(false) implies (<!TYPE_MISMATCH, ERROR_IN_CONTRACT_DESCRIPTION!>"..." + "$<!UNRESOLVED_REFERENCE!>value_1<!>"<!>) }
+    contract { returns(false) implies (<!ERROR_IN_CONTRACT_DESCRIPTION, TYPE_MISMATCH!>"..." + "$<!UNRESOLVED_REFERENCE!>value_1<!>"<!>) }
     return true
 }
 
@@ -41,12 +41,12 @@ fun case_4(): Boolean? {
 
 // TESTCASE NUMBER: 5
 fun case_5(): Boolean? {
-    contract { returns(null) implies <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, ERROR_IN_CONTRACT_DESCRIPTION!>listOf(0)<!> }
+    contract { returns(null) implies <!ERROR_IN_CONTRACT_DESCRIPTION, TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>listOf(0)<!> }
     return null
 }
 
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Boolean): Boolean? {
-    contract { returns(null) implies <!TYPE_MISMATCH, ERROR_IN_CONTRACT_DESCRIPTION!>contract { returns(null) implies (!value_1) }<!> }
+    contract { returns(null) implies <!ERROR_IN_CONTRACT_DESCRIPTION, TYPE_MISMATCH!>contract { returns(null) implies (!value_1) }<!> }
     return null
 }
diff --git a/plugins/sam-with-receiver/sam-with-receiver-cli/testData/diagnostics/singleParameter.kt b/plugins/sam-with-receiver/sam-with-receiver-cli/testData/diagnostics/singleParameter.kt
index 151f887f87f..cb7bc7aac4b 100644
--- a/plugins/sam-with-receiver/sam-with-receiver-cli/testData/diagnostics/singleParameter.kt
+++ b/plugins/sam-with-receiver/sam-with-receiver-cli/testData/diagnostics/singleParameter.kt
@@ -10,7 +10,7 @@ public interface Sam {
 annotation class SamWithReceiver
 
 fun test() {
-    Sam { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>a<!> ->
+    Sam { <!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>a<!> ->
         System.out.println(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>)
     }