[IR] Split INCOMPATIBLE_MATCHING to EXPECT_ACTUAL_MISMATCH & EXPECT_ACTUAL_INCOMPATIBILITY

KT-62590

Review: https://jetbrains.team/p/kt/reviews/12750/timeline

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CommonBackendErrors.kt

@@ -6,9 +6,10 @@
 package org.jetbrains.kotlin.backend.common
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.DECLARATION_NAME
 import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.EXPECT_ACTUAL_ANNOTATION_INCOMPATIBILITY
 import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.INCOMPATIBILITY
-import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.DECLARATION_NAME
+import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.MISMATCH
 import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.EVALUATION_ERROR_EXPLANATION
 import org.jetbrains.kotlin.backend.common.BackendDiagnosticRenderers.SYMBOL_OWNER_DECLARATION_FQ_NAME
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
@@ -25,11 +26,13 @@ import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.classFqName
 import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
 
 object CommonBackendErrors {
     val NO_ACTUAL_FOR_EXPECT by error2<PsiElement, String, ModuleDescriptor>()
-    val INCOMPATIBLE_MATCHING by error3<PsiElement, String, String, ExpectActualCompatibility.MismatchOrIncompatible<*>>()
+    val EXPECT_ACTUAL_MISMATCH by error3<PsiElement, String, String, ExpectActualMatchingCompatibility.Mismatch>()
+    val EXPECT_ACTUAL_INCOMPATIBILITY by error3<PsiElement, String, String, ExpectActualCheckingCompatibility.Incompatible<*>>()
     val ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT by warning3<PsiElement, IrSymbol, IrSymbol, ExpectActualAnnotationsIncompatibilityType<IrConstructorCall>>()
     val EVALUATION_ERROR by error1<PsiElement, String>()
     val ACTUAL_ANNOTATION_CONFLICTING_DEFAULT_ARGUMENT_VALUE by error1<PsiElement, IrValueParameter>()
@@ -48,10 +51,17 @@ object KtDefaultCommonBackendErrorMessages : BaseDiagnosticRendererFactory() {
             MODULE_WITH_PLATFORM,
         )
         map.put(
-            CommonBackendErrors.INCOMPATIBLE_MATCHING,
+            CommonBackendErrors.EXPECT_ACTUAL_MISMATCH,
             "Expect declaration `{0}` doesn''t match actual `{1}` because {2}",
             STRING,
             STRING,
+            MISMATCH
+        )
+        map.put(
+            CommonBackendErrors.EXPECT_ACTUAL_INCOMPATIBILITY,
+            "Expect declaration `{0}` is incompatible with actual `{1}` because {2}",
+            STRING,
+            STRING,
             INCOMPATIBILITY
         )
         map.put(
@@ -76,7 +86,10 @@ object KtDefaultCommonBackendErrorMessages : BaseDiagnosticRendererFactory() {
 }
 
 object BackendDiagnosticRenderers {
-    val INCOMPATIBILITY = Renderer<ExpectActualCompatibility.MismatchOrIncompatible<*>> {
+    val MISMATCH = Renderer<ExpectActualMatchingCompatibility.Mismatch> {
+        it.reason ?: "<unknown>"
+    }
+    val INCOMPATIBILITY = Renderer<ExpectActualCheckingCompatibility.Incompatible<*>> {
         it.reason ?: "<unknown>"
     }
     val SYMBOL_OWNER_DECLARATION_FQ_NAME = Renderer<IrSymbol> {

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt

@@ -279,7 +279,7 @@ private class ExpectActualLinkCollector : IrElementVisitor<Unit, ExpectActualLin
             for ((incompatibility, actualMemberSymbols) in actualSymbolsByIncompatibility) {
                 for (actualSymbol in actualMemberSymbols) {
                     require(actualSymbol is IrSymbol)
-                    diagnosticsReporter.reportIncompatibleExpectActual(expectSymbol, actualSymbol, incompatibility)
+                    diagnosticsReporter.reportExpectActualIncompatibility(expectSymbol, actualSymbol, incompatibility)
                 }
             }
         }
@@ -297,7 +297,7 @@ private class ExpectActualLinkCollector : IrElementVisitor<Unit, ExpectActualLin
             for ((incompatibility, actualMemberSymbols) in actualSymbolsByIncompatibility) {
                 for (actualSymbol in actualMemberSymbols) {
                     require(actualSymbol is IrSymbol)
-                    diagnosticsReporter.reportIncompatibleExpectActual(expectSymbol, actualSymbol, incompatibility)
+                    diagnosticsReporter.reportExpectActualMismatch(expectSymbol, actualSymbol, incompatibility)
                 }
             }
         }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt

@@ -21,9 +21,7 @@ import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualMatcher
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
+import org.jetbrains.kotlin.resolve.multiplatform.*
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
-import org.jetbrains.kotlin.resolve.multiplatform.OptionalAnnotationUtil
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
 
@@ -109,15 +107,30 @@ internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportMissingActual(
     )
 }
 
-internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportIncompatibleExpectActual(
+internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportExpectActualIncompatibility(
     expectSymbol: IrSymbol,
     actualSymbol: IrSymbol,
-    incompatibility: ExpectActualCompatibility.MismatchOrIncompatible<*>
+    incompatibility: ExpectActualCheckingCompatibility.Incompatible<*>,
 ) {
     val expectDeclaration = expectSymbol.owner as IrDeclaration
     val actualDeclaration = actualSymbol.owner as IrDeclaration
     at(expectDeclaration).report(
-        CommonBackendErrors.INCOMPATIBLE_MATCHING,
+        CommonBackendErrors.EXPECT_ACTUAL_INCOMPATIBILITY,
+        expectDeclaration.getNameWithAssert().asString(),
+        actualDeclaration.getNameWithAssert().asString(),
+        incompatibility
+    )
+}
+
+internal fun KtDiagnosticReporterWithImplicitIrBasedContext.reportExpectActualMismatch(
+    expectSymbol: IrSymbol,
+    actualSymbol: IrSymbol,
+    incompatibility: ExpectActualMatchingCompatibility.Mismatch,
+) {
+    val expectDeclaration = expectSymbol.owner as IrDeclaration
+    val actualDeclaration = actualSymbol.owner as IrDeclaration
+    at(expectDeclaration).report(
+        CommonBackendErrors.EXPECT_ACTUAL_MISMATCH,
         expectDeclaration.getNameWithAssert().asString(),
         actualDeclaration.getNameWithAssert().asString(),
         incompatibility

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeFunctionTypeParameterNamesInOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base {
     open fun <T> foo(t: T) {}
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeLateinitInOverride.fir.kt

@@ -7,7 +7,7 @@ open class Base {
     open lateinit var green: String
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeModalityFromAbstractToFinalInOverride.fir.kt

@@ -5,7 +5,7 @@ interface Base {
     fun foo()
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!> : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!> : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeModalityFromAbstractToOpenInOverride.fir.kt

@@ -3,7 +3,7 @@
 interface Base {
     fun foo()
 }
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!>() : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Foo<!>() : Base<!>
 
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeModalityFromOpenToAbstractInOverride.fir.kt

@@ -3,7 +3,7 @@
 interface Base {
     fun foo() {}
 }
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect abstract class Foo() : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect abstract class Foo() : Base<!>
 
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeModalityFromOpenToFinalInOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base {
     open fun foo() {}
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeModalityOfSubstitutedFakeOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base<T> {
     open fun foo(t: T) {}
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<String><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<String><!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeModalityOfToStringInOverride.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeParameterNameInOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base {
     open fun foo(param: Int) {}
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo1 : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo1 : Base<!>
 expect open class Foo2 : Base
 expect open class Foo3 {
     open fun foo(param: Int)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeSetterVisibilityInOverride.fir.kt

@@ -6,7 +6,7 @@ open class Base {
         protected set
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeVarargModifierInOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base {
     open fun foo(vararg bar: Int) {}
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/changeVisibilityInOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base {
     protected open fun foo() {}
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/covariantFunctionOverride.fir.kt

@@ -6,7 +6,7 @@ open class Base {
     open fun foo(): Any = ""
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/covariantOverrideGenericUpperBound.fir.kt

@@ -7,7 +7,7 @@ open class Base {
     open fun foo(): I = null!!
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo<T : I> : Base {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<T : I> : Base {
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/covariantOverrideGenerics.fir.kt

@@ -5,7 +5,7 @@ open class Base<R> {
     open fun foo(): R = null!!
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo<R, T : R> : Base<R> {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo<R, T : R> : Base<R> {
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/covariantPropertyOverride.fir.kt

@@ -6,7 +6,7 @@ open class Base {
     open fun foo(): String = ""
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/flexibleTypesMatching.fir.kt

@@ -5,7 +5,7 @@ expect open class Base {
     open fun foo(): MutableList<String>
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
 
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/propertyKindOverride.fir.kt

@@ -5,7 +5,7 @@ open class Base {
     open val foo: Int = 1
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/actualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker/severalMismatches.fir.kt

@@ -8,7 +8,7 @@ open class Base() {
     protected open fun overrideVisibility(): Any = ""
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect open class Foo : Base {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Foo : Base {
     fun existingMethod()
     val existingParam: Int
 }<!>

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/actualInnerClassMissingMember.fir.kt

@@ -2,8 +2,8 @@
 // FILE: common.kt
 annotation class Ann
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class A {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class A {
-    <!INCOMPATIBLE_MATCHING{JVM}!>class B {
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>class B {
         @Ann
         fun foo()
         <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun missingOnActual()<!>

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/arrayVsVararg.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}("A; A; some expected members have no actual ones")!>expect annotation class A<!INCOMPATIBLE_MATCHING{JVM}("<init>; <init>; some value parameter is vararg in one declaration and non-vararg in the other")!>(vararg val x: String)<!><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class A<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>(vararg val x: String)<!><!>
 
 @A("abc", "foo", "bar")
 fun test() {}

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/classScopeViaTypealiasIncompatible.fir.kt

@@ -2,13 +2,13 @@
 // FILE: common.kt
 annotation class Ann
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class WeakIncompatibility {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class WeakIncompatibility {
-    <!INCOMPATIBLE_MATCHING{JVM}!>@Ann
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>@Ann
     fun foo(p: String)<!>
 }<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class StrongIncompatibility {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class StrongIncompatibility {
-    <!INCOMPATIBLE_MATCHING{JVM}!>@Ann
+    <!EXPECT_ACTUAL_MISMATCH{JVM}!>@Ann
     fun foo(p: Int)<!>
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/enumEntries.fir.kt

@@ -2,7 +2,7 @@
 // FILE: common.kt
 annotation class Ann
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect enum class E {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class E {
     @Ann
     FOO,
     <!NO_ACTUAL_FOR_EXPECT{JVM}!>MISSING_ON_ACTUAL<!>

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typeAliasWithArray.fir.kt

@@ -3,7 +3,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class Mode {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect enum class Mode {
     Throughput, AverageTime
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typeParameters.fir.kt

@@ -13,7 +13,7 @@ expect class ViaTypealias<@Ann A>
 
 expect class TypealiasParamNotAccepted<@Ann A>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun <@Ann A, @Ann B> withIncompatibility()<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <@Ann A, @Ann B> withIncompatibility()<!>
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typeUsage.fir.kt

@@ -19,9 +19,9 @@ interface I2
 
 expect fun <T> severalBounds() where T : I1, T : @Ann I2
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun <T> severalBoundsDifferentOrder() where T : I2, T : @Ann I1<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> severalBoundsDifferentOrder() where T : I2, T : @Ann I1<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun <T> lessTypeParamBoundsOnActual() where T : I1, T : @Ann I2<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> lessTypeParamBoundsOnActual() where T : I1, T : @Ann I2<!>
 
 expect fun @Ann Any.onReceiver()
 
@@ -51,7 +51,7 @@ expect fun qualifierPartsMatching(arg: WithNested<String>.Nested<@Ann String>)
 
 expect fun qualifierPartsNonMatching(arg: WithNested<String>.Nested<@Ann String>)
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun funTypeVsUserType(arg: () -> @Ann String)<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun funTypeVsUserType(arg: () -> @Ann String)<!>
 
 expect fun funcTypeReturnType(arg: () -> @Ann Any)
 

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/typeUsageWithUnresolvedReference.fir.kt

@@ -3,7 +3,7 @@
 @Target(AnnotationTarget.TYPE)
 annotation class Ann
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun <T : @Ann Any> foo()<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T : @Ann Any> foo()<!>
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/valueParameters.fir.kt

@@ -7,7 +7,7 @@ expect fun inMethod(@Ann arg: String)
 
 expect class InConstructor(@Ann arg: String)
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun withIncopatibility(@Ann p1: String, @Ann p2: String)<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun withIncopatibility(@Ann p1: String, @Ann p2: String)<!>
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/annotationMatching/withOtherIncomatibilities.fir.kt

@@ -2,10 +2,10 @@
 // FILE: common.kt
 annotation class Ann
 
-<!INCOMPATIBLE_MATCHING{JVM}!>@Ann
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>@Ann
 expect inline fun hasWeakIncompatibility()<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>@Ann
+<!EXPECT_ACTUAL_MISMATCH{JVM}, EXPECT_ACTUAL_MISMATCH{JVM}!>@Ann
 expect fun hasStrongIncompatibility(arg: Int)<!>
 
 expect fun hasStrongIncompatibility(arg: Double)

compiler/testData/diagnostics/tests/multiplatform/complexMatchings/expectCtorlessFinalToActualObject.fir.kt

@@ -2,27 +2,27 @@
 // FILE: common.kt
 
 expect class E01
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E02()<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E02()<!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class E03<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class E03<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E04 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E04 {
     constructor()
 }<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E05(e: E01)<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E05(e: E01)<!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E06 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E06 {
     constructor(e: E02)
 }<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect interface I01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface I01<!>
 
 expect class M01 {
     fun foo()
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect enum class ENUM01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class ENUM01<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect annotation class ANNO01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class ANNO01<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/complexMatchings/expectCtorlessFinalToActualObjectViaTypealias.fir.kt

@@ -2,27 +2,27 @@
 // FILE: common.kt
 
 expect class E01
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E02()<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E02()<!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class E03<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class E03<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E04 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E04 {
     constructor()
 }<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E05(e: E01)<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E05(e: E01)<!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class E06 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class E06 {
     constructor(e: E02)
 }<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect interface I01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface I01<!>
 
 expect class M01 {
     fun foo()
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect enum class ENUM01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect enum class ENUM01<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect annotation class ANNO01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class ANNO01<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/delegation.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class Foo {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
-    <!INCOMPATIBLE_MATCHING{JVM}!>fun foo(param: Int = 1)<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>fun foo(param: Int = 1)<!>
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualFakeOverride/simpleIncompatible.fir.kt

@@ -1,6 +1,6 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class Foo {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
     fun foo(param: Int = 1)
     <!NO_ACTUAL_FOR_EXPECT{JVM}!>fun missingOnActual()<!>
 }<!>

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/methodDefaultArgsViaActualTypealias.fir.kt

@@ -17,7 +17,7 @@ expect class WithDefaultArgFromSuper : I {
     override fun methodWithDefaultArg(s: String)
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class WithIncompatibility {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class WithIncompatibility {
     fun foo(p: String = "common")
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/defaultArguments/nestedAnnotationClassViaActualTypealias.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class DefaultArgsInNestedClass {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class DefaultArgsInNestedClass {
-    <!INCOMPATIBLE_MATCHING{JVM}!>annotation class Nested<!INCOMPATIBLE_MATCHING{JVM}!>(val p: String = "")<!><!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>annotation class Nested<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>(val p: String = "")<!><!>
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/expectInterfaceApplicability.fir.kt

@@ -1,13 +1,13 @@
 // MODULE: m1-common
 // FILE: common.kt
 // TODO: .fir.kt version is just a stub.
-<!INCOMPATIBLE_MATCHING{JVM}!>expect interface My {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface My {
     open fun openFunPositive()
-    <!INCOMPATIBLE_MATCHING{JVM}!>open fun openFunNegative()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open fun openFunNegative()<!>
     abstract fun abstractFun()
 
     open val openValPositive: Int
-    <!INCOMPATIBLE_MATCHING{JVM}!>open val openValNegative: Int<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open val openValNegative: Int<!>
     abstract val abstractVal: Int
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.fir.kt

@@ -4,7 +4,7 @@
 interface A
 interface B
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun <T> List<T>.foo() where T : A, T : B<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun <T> List<T>.foo() where T : A, T : B<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDefaultValuesInAnnotationViaTypealias.fir.kt

@@ -7,7 +7,7 @@ expect annotation class Foo3
 expect annotation class Foo4
 expect annotation class Foo5()
 expect annotation class Foo6()
-<!INCOMPATIBLE_MATCHING{JVM}!>expect annotation class Foo7<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect annotation class Foo7<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
 
 @<!UNRESOLVED_REFERENCE!>Foo1<!>
 fun foo() {}

compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDifferentConstructors.fir.kt

@@ -5,9 +5,9 @@ expect class Foo1
 expect class Foo2
 expect class Foo3
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class Bar1<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Bar1<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class Bar2<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Bar2<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class Bar3<!INCOMPATIBLE_MATCHING{JVM}!>()<!><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Bar3<!EXPECT_ACTUAL_MISMATCH{JVM}!>()<!><!>
 expect class Bar4()
 expect class Bar5()
 expect class Bar6()

compiler/testData/diagnostics/tests/multiplatform/headerClass/equalsOverrideInActualInterface.fir.kt

@@ -1,5 +1,5 @@
 // MODULE: m1-common
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect interface Base<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface Base<!>
 
 // MODULE: m1-jvm()()(m1-common)
 actual interface Base {

compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.fir.kt

@@ -3,12 +3,12 @@
 // FILE: common.kt
 
 expect fun foo1(x: Int)
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>expect fun foo2(x: Int)<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}, EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun foo2(x: Int)<!>
 
 expect class NoArgConstructor()
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun foo3(): Int<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun foo3(): Int<!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun foo4(): Int<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun foo4(): Int<!>
 
 // MODULE: m2-jvm()()(m1-common)
 

compiler/testData/diagnostics/tests/multiplatform/headerClass/expectFunInterface.fir.kt

@@ -5,7 +5,7 @@ expect fun interface F1 {
     fun run()
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun interface F2 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun interface F2 {
     fun run()
 }<!>
 
@@ -21,7 +21,7 @@ expect fun interface F5 {
     fun run()
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun interface F6 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun interface F6 {
     fun run()
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.fir.kt

@@ -3,8 +3,8 @@
 // FILE: common.kt
 
 expect class C1
-<!INCOMPATIBLE_MATCHING{JVM}!>expect interface C2<A><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface C2<A><!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect interface C3<B><!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect interface C3<B><!>
 expect interface C4<D, E>
 expect interface C5<F, G>
 expect interface C6<H>

compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActual.fir.kt

@@ -2,19 +2,19 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class Container {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Container {
     fun publicFun()
 
     internal fun internalFun1()
     internal fun internalFun2()
-    <!INCOMPATIBLE_MATCHING{JVM}!>internal fun internalFun3()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>internal fun internalFun3()<!>
 
     protected fun protectedFun1()
     protected fun protectedFun2()
-    <!INCOMPATIBLE_MATCHING{JVM}!>protected fun protectedFun3()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>protected fun protectedFun3()<!>
 
-    <!INCOMPATIBLE_MATCHING{JVM}!>open internal fun openInternalFun()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open internal fun openInternalFun()<!>
-    <!INCOMPATIBLE_MATCHING{JVM}!>open fun openPublicFun()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>open fun openPublicFun()<!>
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActualViaTypeAlias_openMember.fir.kt

@@ -2,8 +2,8 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class Container {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class Container {
-    <!INCOMPATIBLE_MATCHING{JVM}!>internal open fun internalFun()<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>internal open fun internalFun()<!>
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.fir.kt

@@ -14,7 +14,7 @@ expect class C {
     <!WRONG_MODIFIER_TARGET!>expect<!> inner class I
 }
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class D {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class D {
     <!NO_ACTUAL_FOR_EXPECT{JVM}!>class N<!>
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.fir.kt

@@ -1,9 +1,9 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class Foo {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class Foo {
     fun bar(): String
-    <!INCOMPATIBLE_MATCHING{JVM}!>fun bas(f: Int)<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>fun bas(f: Int)<!>
 }<!>
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/hmpp/kt57320.fir.kt

@@ -26,7 +26,7 @@ interface KotlinXStringDemoInterface {
     val value: String
 }
 
-<!INCOMPATIBLE_MATCHING{JS}!>expect fun StringDemoInterface.plusK(): String<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JS}!>expect fun StringDemoInterface.plusK(): String<!>
 
 // MODULE: js()()(common, intermediate)
 // TARGET_PLATFORM: JS
@@ -34,7 +34,7 @@ interface KotlinXStringDemoInterface {
 // FILE: StringDemoInterface.kt
 actual typealias StringDemoInterface = KotlinXStringDemoInterface
 
-actual fun StringDemoIn<!INCOMPATIBLE_MATCHING!>terface.<!ACTUAL_WITHOUT_EXPECT("actual fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>plusK<!>() = <!EXPECT_CLASS_AS_FUNCTION!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!>
+actual fun StringDemoIn<!EXPECT_ACTUAL_INCOMPATIBILITY!>terface.<!ACTUAL_WITHOUT_EXPECT("actual fun StringDemoInterface.plusK(): <ERROR TYPE REF: Unresolved name: value>; The following declaration is incompatible:    expect fun StringDemoInterface.plusK(): String")!>plusK<!>() = <!EXPECT_CLASS_AS_FUNCTION!>StringValue<!>(value).plus("K")<!>.<!UNRESOLVED_REFERENCE!>value<!>
 
 // FILE: main.kt
 class StringDemo(override val value: String) : StringDemoInterface

compiler/testData/diagnostics/tests/multiplatform/implicitActualFakeOverride_AbstractMap.fir.kt

@@ -3,7 +3,7 @@
 // FILE: common.kt
 
 // K2: false positve INCOMPATIBLE_MATCHING: KT-60155
-<!INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}, INCOMPATIBLE_MATCHING{JVM}!>public expect abstract class AbstractMutableMap<K, V> : MutableMap<K, V> {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>public expect abstract class AbstractMutableMap<K, V> : MutableMap<K, V> {
     override val values: MutableCollection<V>
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/java/implicitJavaActualization_multipleActuals.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class <!PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo<!>(i: Int) {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class <!PACKAGE_OR_CLASSIFIER_REDECLARATION!>Foo<!>(i: Int) {
     fun foo()
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/kt54827.fir.kt

@@ -1,6 +1,6 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!INCOMPATIBLE_MATCHING{JVM}!>expect class SomeClass<T> {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect class SomeClass<T> {
     fun foo()
 }<!>
 

compiler/testData/diagnostics/tests/multiplatform/returnTypeVsGenericsUpperBoundIncompatibility.fir.kt

@@ -2,7 +2,7 @@
 // FILE: common.kt
 
 interface A
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun <T : A> foo(t: T): String<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect fun <T : A> foo(t: T): String<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.fir.kt

@@ -1,7 +1,7 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}!>inline expect fun inlineFun()<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>inline expect fun inlineFun()<!>
 expect fun nonInlineFun()
 
 // MODULE: m2-jvm()()(m1-common)

compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.fir.kt

@@ -3,15 +3,15 @@
 // FILE: common.kt
 
 expect fun f1(s: () -> String)
-<!INCOMPATIBLE_MATCHING{JVM}!>expect inline fun f2(s: () -> String)<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect inline fun f2(s: () -> String)<!>
 expect inline fun f3(noinline s: () -> String)
 
 expect fun f4(s: () -> String)
-<!INCOMPATIBLE_MATCHING{JVM}!>expect inline fun f5(s: () -> String)<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect inline fun f5(s: () -> String)<!>
 expect inline fun f6(crossinline s: () -> String)
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun f7(x: Any)<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun f7(x: Any)<!>
-<!INCOMPATIBLE_MATCHING{JVM}!>expect fun f8(vararg x: Any)<!>
+<!EXPECT_ACTUAL_MISMATCH{JVM}!>expect fun f8(vararg x: Any)<!>
 
 // MODULE: m2-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/typealias/actualTypealiasToNothing.fir.kt

@@ -1,8 +1,8 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E01<!>
-<!INCOMPATIBLE_MATCHING{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E02<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E02<!>
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/typealias/actualTypealiasToNothing_oldLanguageVersion.fir.kt

@@ -2,8 +2,8 @@
 // MODULE: m1-common
 // FILE: common.kt
 
-<!INCOMPATIBLE_MATCHING{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E01<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E01<!>
-<!INCOMPATIBLE_MATCHING{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E02<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}, NO_ACTUAL_FOR_EXPECT{JVM}!>expect class E02<!>
 
 // MODULE: m1-jvm()()(m1-common)
 // FILE: jvm.kt

compiler/testData/diagnostics/tests/multiplatform/varSetterVisibility.fir.kt

@@ -1,19 +1,19 @@
 // MODULE: m1-common
 // FILE: common.kt
-<!INCOMPATIBLE_MATCHING{JVM}!>expect var v1: Boolean<!>
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect var v1: Boolean<!>
 
 expect var v2: Boolean
     internal set
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect var v3: Boolean
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect var v3: Boolean
     internal set<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class C {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class C {
-    <!INCOMPATIBLE_MATCHING{JVM}!>var foo: Boolean<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>var foo: Boolean<!>
 }<!>
 
-<!INCOMPATIBLE_MATCHING{JVM}!>expect open class C2 {
+<!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>expect open class C2 {
-    <!INCOMPATIBLE_MATCHING{JVM}!>var foo: Boolean<!>
+    <!EXPECT_ACTUAL_INCOMPATIBILITY{JVM}!>var foo: Boolean<!>
 }<!>
 
 // MODULE: m1-jvm()()(m1-common)

compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/output.txt

@@ -5,6 +5,6 @@ Output:
 -- JVM --
 Exit code: COMPILATION_ERROR
 Output:
-compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/common.kt:1:1: error: expect declaration `Foo` doesn't match actual `Foo` because class kinds are different (class, interface, object, enum, annotation)
+compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier/common.kt:1:1: error: expect declaration `Foo` is incompatible with actual `Foo` because class kinds are different (class, interface, object, enum, annotation)
 expect class Foo
 ^