[FIR] Improve "actual ignorability not match expect" diagnostic

sandwwraith · Space Team · commit 2b64be4984d0 · 2025-09-04T18:55:29.000Z
by adding ignorability statuses to its text.
diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/HLDiagnosticConverter.kt
@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
+import org.jetbrains.kotlin.resolve.ReturnValueStatus
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
 import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
@@ -389,6 +390,7 @@ internal object FirToKtConversionCreator {
         IncompatibleVersionErrorData::class,
         RelationToType::class,
         KotlinTarget::class,
+        ReturnValueStatus::class,
     )
 
     private val KType.kClass: KClass<*>
diff --git a/analysis/analysis-api-fir/gen/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDataClassConverters.kt b/analysis/analysis-api-fir/gen/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDataClassConverters.kt
@@ -4937,8 +4937,9 @@ internal val KT_DIAGNOSTIC_CONVERTER = KaDiagnosticConverterBuilder.buildConvert
     add(FirErrors.ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT) { firDiagnostic ->
         ActualIgnorabilityNotMatchExpectImpl(
             firSymbolBuilder.buildSymbol(firDiagnostic.a),
-            firSymbolBuilder.buildSymbol(firDiagnostic.b),
-            firDiagnostic.c,
+            firDiagnostic.b,
+            firSymbolBuilder.buildSymbol(firDiagnostic.c),
+            firDiagnostic.d,
             firDiagnostic as KtPsiDiagnostic,
             token,
         )
diff --git a/analysis/analysis-api-fir/gen/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDiagnostics.kt b/analysis/analysis-api-fir/gen/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDiagnostics.kt
@@ -86,6 +86,7 @@ import org.jetbrains.kotlin.psi.KtWhenCondition
 import org.jetbrains.kotlin.psi.KtWhenEntry
 import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
+import org.jetbrains.kotlin.resolve.ReturnValueStatus
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility.Mismatch
@@ -3460,8 +3461,9 @@ sealed interface KaFirDiagnostic<PSI : PsiElement> : KaDiagnosticWithPsi<PSI> {
     interface ActualIgnorabilityNotMatchExpect : KaFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ActualIgnorabilityNotMatchExpect::class
         val expectDeclaration: KaSymbol
+        val expectIgnorability: ReturnValueStatus
         val actualDeclaration: KaSymbol
-        val reason: String
+        val actualIgnorability: ReturnValueStatus
     }
 
     interface OptionalDeclarationOutsideOfAnnotationEntry : KaFirDiagnostic<PsiElement> {
diff --git a/analysis/analysis-api-fir/gen/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/gen/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KaFirDiagnosticsImpl.kt
@@ -87,6 +87,7 @@ import org.jetbrains.kotlin.psi.KtWhenCondition
 import org.jetbrains.kotlin.psi.KtWhenEntry
 import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
+import org.jetbrains.kotlin.resolve.ReturnValueStatus
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility.Mismatch
@@ -4146,8 +4147,9 @@ internal class ActualAnnotationsNotMatchExpectImpl(
 
 internal class ActualIgnorabilityNotMatchExpectImpl(
     override val expectDeclaration: KaSymbol,
+    override val expectIgnorability: ReturnValueStatus,
     override val actualDeclaration: KaSymbol,
-    override val reason: String,
+    override val actualIgnorability: ReturnValueStatus,
     firDiagnostic: KtPsiDiagnostic,
     token: KaLifetimeToken,
 ) : KaAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KaFirDiagnostic.ActualIgnorabilityNotMatchExpect
diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
@@ -1685,8 +1685,9 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         // Same as expectActualIncompatibilityError, but warning
         val ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT by warning<KtNamedDeclaration>(PositioningStrategy.DECLARATION_NAME_ONLY) {
             parameter<Symbol>("expectDeclaration")
+            parameter<ReturnValueStatus>("expectIgnorability")
             parameter<Symbol>("actualDeclaration")
-            parameter<String>("reason")
+            parameter<ReturnValueStatus>("actualIgnorability")
         }
 
         val OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY by error<PsiElement>()
diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
@@ -137,6 +137,7 @@ import org.jetbrains.kotlin.psi.KtWhenCondition
 import org.jetbrains.kotlin.psi.KtWhenEntry
 import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
+import org.jetbrains.kotlin.resolve.ReturnValueStatus
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility.Mismatch
@@ -834,7 +835,7 @@ object FirErrors : KtDiagnosticsContainer() {
     val EXPECT_ACTUAL_OPT_IN_ANNOTATION: KtDiagnosticFactory0 = KtDiagnosticFactory0("EXPECT_ACTUAL_OPT_IN_ANNOTATION", ERROR, SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER, KtNamedDeclaration::class, getRendererFactory())
     val ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION: KtDiagnosticFactory1<ClassId> = KtDiagnosticFactory1("ACTUAL_TYPEALIAS_TO_SPECIAL_ANNOTATION", ERROR, SourceElementPositioningStrategies.TYPEALIAS_TYPE_REFERENCE, KtTypeAlias::class, getRendererFactory())
     val ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT: KtDiagnosticFactory4<FirBasedSymbol<*>, FirBasedSymbol<*>, KtSourceElement?, ExpectActualAnnotationsIncompatibilityType<FirAnnotation>> = KtDiagnosticFactory4("ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT", WARNING, SourceElementPositioningStrategies.DECLARATION_NAME_ONLY, KtElement::class, getRendererFactory())
-    val ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT: KtDiagnosticFactory3<FirBasedSymbol<*>, FirBasedSymbol<*>, String> = KtDiagnosticFactory3("ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT", WARNING, SourceElementPositioningStrategies.DECLARATION_NAME_ONLY, KtNamedDeclaration::class, getRendererFactory())
+    val ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT: KtDiagnosticFactory4<FirBasedSymbol<*>, ReturnValueStatus, FirBasedSymbol<*>, ReturnValueStatus> = KtDiagnosticFactory4("ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT", WARNING, SourceElementPositioningStrategies.DECLARATION_NAME_ONLY, KtNamedDeclaration::class, getRendererFactory())
     val OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY: KtDiagnosticFactory0 = KtDiagnosticFactory0("OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY", ERROR, SourceElementPositioningStrategies.DEFAULT, PsiElement::class, getRendererFactory())
     val OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE: KtDiagnosticFactory0 = KtDiagnosticFactory0("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE", ERROR, SourceElementPositioningStrategies.DEFAULT, PsiElement::class, getRendererFactory())
     val OPTIONAL_EXPECTATION_NOT_ON_EXPECTED: KtDiagnosticFactory0 = KtDiagnosticFactory0("OPTIONAL_EXPECTATION_NOT_ON_EXPECTED", ERROR, SourceElementPositioningStrategies.DEFAULT, PsiElement::class, getRendererFactory())
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt
@@ -186,6 +186,8 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker(MppChecker
             // A nicer diagnostic for functions with default params
             if (declaration is FirFunction && incompatibility == ExpectActualIncompatibility.ActualFunctionWithOptionalParameters) {
                 reporter.reportOn(declaration.source, FirErrors.ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS)
+            } else if (incompatibility == ExpectActualIncompatibility.IgnorabilityIsDifferent) {
+                reportIgnorabilityIncompatibleMembers(expectedSingleCandidate, symbol, source)
             } else {
                 reporter.reportOn(
                     source,
@@ -285,24 +287,33 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker(MppChecker
         }
     }
 
+    context(reporter: DiagnosticReporter, context: CheckerContext)
+    private fun reportIgnorabilityIncompatibleMembers(
+        expect: FirBasedSymbol<*>,
+        actual: FirBasedSymbol<*>,
+        source: KtSourceElement?,
+    ) {
+        val expectMember =
+            expect as? FirCallableSymbol<*> ?: error("Ignorability incompatibility can be reported only for callables")
+        val actualMember =
+            actual as? FirCallableSymbol<*> ?: error("Ignorability incompatibility can be reported only for callables")
+        reporter.reportOn(
+            source,
+            FirErrors.ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT,
+            expectMember,
+            expectMember.resolvedStatus.returnValueStatus,
+            actualMember,
+            actualMember.resolvedStatus.returnValueStatus
+        )
+    }
+
     context(reporter: DiagnosticReporter, context: CheckerContext)
     private fun reportIgnorabilityIncompatibleMembers(
         ignorabilityIncompatibleMembers: List<MemberIncompatibility<FirBasedSymbol<*>>>,
         source: KtSourceElement?,
     ) {
-        // Separate handling because it is a warning
         for (member in ignorabilityIncompatibleMembers) {
-            val expectMember =
-                member.expect as? FirCallableSymbol<*> ?: error("Ignorability incompatibility can be reported only for callables")
-            val actualMember =
-                member.actual as? FirCallableSymbol<*> ?: error("Ignorability incompatibility can be reported only for callables")
-            reporter.reportOn(
-                source,
-                FirErrors.ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT,
-                expectMember,
-                actualMember,
-                member.incompatibility.reason
-            )
+            reportIgnorabilityIncompatibleMembers(member.expect, member.actual, source)
         }
     }
 
@@ -408,6 +419,7 @@ object FirExpectActualDeclarationChecker : FirBasicDeclarationChecker(MppChecker
 private fun ExpectActualIncompatibility<*>.toDiagnostic() = when (this) {
     ExpectActualIncompatibility.ActualFunctionWithOptionalParameters -> error("unreachable")
     is ExpectActualIncompatibility.ClassScopes<*> -> error("unreachable")
+    ExpectActualIncompatibility.IgnorabilityIsDifferent -> error("Should be handled before")
 
     ExpectActualIncompatibility.ClassKind -> FirErrors.EXPECT_ACTUAL_INCOMPATIBLE_CLASS_KIND
     ExpectActualIncompatibility.ClassModifiers -> FirErrors.EXPECT_ACTUAL_INCOMPATIBLE_CLASS_MODIFIERS
@@ -436,5 +448,4 @@ private fun ExpectActualIncompatibility<*>.toDiagnostic() = when (this) {
     is ExpectActualIncompatibility.Modality -> FirErrors.EXPECT_ACTUAL_INCOMPATIBLE_MODALITY
     is ExpectActualIncompatibility.PropertySetterVisibility -> FirErrors.EXPECT_ACTUAL_INCOMPATIBLE_PROPERTY_SETTER_VISIBILITY
     is ExpectActualIncompatibility.Visibility -> FirErrors.EXPECT_ACTUAL_INCOMPATIBLE_VISIBILITY
-    ExpectActualIncompatibility.IgnorabilityIsDifferent -> FirErrors.ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT
 }
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.metadata.deserialization.VersionRequirement
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.ReturnValueStatus
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
 import java.text.MessageFormat
 
@@ -386,6 +387,14 @@ object FirDiagnosticRenderers {
         name?.asString()?.takeIf { it.isNotBlank() }?.let { " of '$it'" } ?: ""
     }
 
+    val IGNORABILITY_STATUS = Renderer { status: ReturnValueStatus ->
+        when (status) {
+            ReturnValueStatus.MustUse -> "must-use"
+            ReturnValueStatus.ExplicitlyIgnorable -> "ignorable"
+            ReturnValueStatus.Unspecified -> "unspecified (implicitly ignorable)"
+        }
+    }
+
     val SYMBOL_WITH_CONTAINING_DECLARATION = Renderer { symbol: FirBasedSymbol<*> ->
         val containingClassId = when (symbol) {
             is FirCallableSymbol<*> -> symbol.callableId?.classId
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt
@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.DECL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.DECLARATION_NAME
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FOR_OPTIONAL_OPERATOR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.FUNCTIONAL_TYPE_KINDS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.IGNORABILITY_STATUS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.KOTLIN_TARGETS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.MODULE_DATA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NAME_OF_CONTAINING_DECLARATION_OR_FILE
@@ -2978,8 +2979,9 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
         )
         map.put(
             ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT,
-            "Ignorability statuses for expect declaration ''{0}'' and actual declaration ''{1}'' do not match. @IgnorableReturnValue declaration cannot be actualized with Must-Use declaration, and vice versa.",
-            SYMBOL_WITH_CONTAINING_DECLARATION, SYMBOL_WITH_CONTAINING_DECLARATION, EMPTY
+            "Ignorability statuses for expect and actual declarations are different. Expect declaration {0} is {1} and actual declaration {2} is {3}. " +
+                    "Different statuses may result in inconsistent and incorrect warnings.",
+            SYMBOL_WITH_CONTAINING_DECLARATION, IGNORABILITY_STATUS, SYMBOL_WITH_CONTAINING_DECLARATION, IGNORABILITY_STATUS,
         )
         map.put(
             OPTIONAL_DECLARATION_OUTSIDE_OF_ANNOTATION_ENTRY,
diff --git a/compiler/testData/diagnostics/tests/crv/expectActual/actualizeInheritance.fir.kt b/compiler/testData/diagnostics/tests/crv/expectActual/actualizeInheritance.fir.kt
@@ -29,7 +29,7 @@ open class BaseFoo {
 
 // FILE: jvm.kt
 
-actual class <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; 'fun x(): String' defined in 'BaseFoo'"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; 'fun ign(): String' defined in 'BaseFoo'"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; 'constructor(): Foo' defined in 'Foo'")!>Foo<!> : BaseFoo() {
+actual class <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; must-use; 'fun x(): String' defined in 'BaseFoo'; ignorable"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; ignorable; 'fun ign(): String' defined in 'BaseFoo'; must-use"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; must-use; 'constructor(): Foo' defined in 'Foo'; unspecified (implicitly ignorable)")!>Foo<!> : BaseFoo() {
 }
 
 fun main() {
diff --git a/compiler/testData/diagnostics/tests/crv/expectActual/actualizeInheritanceUnspecified.fir.kt b/compiler/testData/diagnostics/tests/crv/expectActual/actualizeInheritanceUnspecified.fir.kt
@@ -34,7 +34,7 @@ public class JavaFoo {
 
 // Foo.<init> and Java methods are Unspecified.
 // We report mismatch to Unspecified only if there is a meaningful (i.e. member) declaration to report on.
-actual class <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; 'constructor(): Foo' defined in 'Foo'")!>Foo<!> : JavaFoo() {
+actual class <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; must-use; 'constructor(): Foo' defined in 'Foo'; unspecified (implicitly ignorable)")!>Foo<!> : JavaFoo() {
 }
 
 fun main() {
diff --git a/compiler/testData/diagnostics/tests/crv/expectActual/actualizeSpecified.fir.kt b/compiler/testData/diagnostics/tests/crv/expectActual/actualizeSpecified.fir.kt
@@ -32,15 +32,15 @@ fun commonMain() {
 // ign: ExplicitlyIgnorable -> MustUse :error:
 @MustUseReturnValue
 actual class Foo actual constructor() {
-    @IgnorableReturnValue actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT!>x<!>(): String = ""
-    actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT!>ign<!>(): String = ""
+    @IgnorableReturnValue actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; must-use; 'actual fun x(): String' defined in 'Foo'; ignorable")!>x<!>(): String = ""
+    actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; ignorable; 'actual fun ign(): String' defined in 'Foo'; must-use")!>ign<!>(): String = ""
     actual val p: Int = 42
     fun notActual(): String = ""
 }
 
 // These two are Unspecified, because annotation is not on file:
 
-actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT!>toplvl<!>(): String = "" // MustUse -> Unspecified is not allowed
+actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun toplvl(): String'; must-use; 'actual fun toplvl(): String'; unspecified (implicitly ignorable)")!>toplvl<!>(): String = "" // MustUse -> Unspecified is not allowed
 actual fun ignToplvl(): String = "" // Ignorable -> Unspecified is allowed
 
 fun main() {
diff --git a/compiler/testData/diagnostics/tests/crv/expectActual/actualizeTypealias.fir.kt b/compiler/testData/diagnostics/tests/crv/expectActual/actualizeTypealias.fir.kt
@@ -29,7 +29,7 @@ open class BaseFoo {
 
 // FILE: jvm.kt
 
-actual typealias <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; 'fun x(): String' defined in 'BaseFoo'"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; 'fun ign(): String' defined in 'BaseFoo'")!>Foo<!> = BaseFoo
+actual typealias <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; must-use; 'fun x(): String' defined in 'BaseFoo'; ignorable"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; ignorable; 'fun ign(): String' defined in 'BaseFoo'; must-use")!>Foo<!> = BaseFoo
 
 fun main() {
     <!RETURN_VALUE_NOT_USED!>Foo()<!>
diff --git a/compiler/testData/diagnostics/tests/crv/expectActual/actualizeUnspecified.fir.kt b/compiler/testData/diagnostics/tests/crv/expectActual/actualizeUnspecified.fir.kt
@@ -30,10 +30,10 @@ fun commonMain() {
 // <init>, x, p: Unspecifed -> MustUse is not allowed
 // ign: Unspecified -> ExplicitlyIgnorable is allowed
 @MustUseReturnValue
-actual class Foo <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT!>actual constructor()<!> {
-    actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT!>x<!>(): String = ""
+actual class Foo <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; unspecified (implicitly ignorable); 'actual constructor(): Foo' defined in 'Foo'; must-use")!>actual constructor()<!> {
+    actual fun <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; unspecified (implicitly ignorable); 'actual fun x(): String' defined in 'Foo'; must-use")!>x<!>(): String = ""
     @IgnorableReturnValue actual fun ign(): String = ""
-    actual val <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT!>p<!>: Int = 42
+    actual val <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect val p: Int' defined in 'Foo'; unspecified (implicitly ignorable); 'actual val p: Int' defined in 'Foo'; must-use")!>p<!>: Int = 42
     fun notActual(): String = ""
 }
 
diff --git a/core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt b/core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt
@@ -36,7 +36,7 @@ sealed class ExpectActualMatchingCompatibility {
  *
  * @see ExpectActualMatchingCompatibility
  */
-sealed class ExpectActualIncompatibility<out D>(val reason: String) {
+sealed class ExpectActualIncompatibility<out D>(open val reason: String) {
     object ClassTypeParameterCount : ExpectActualIncompatibility<Nothing>(TYPE_PARAMETER_COUNT)
 
     // Callables
@@ -54,7 +54,9 @@ sealed class ExpectActualIncompatibility<out D>(val reason: String) {
         ExpectActualIncompatibility<Nothing>("some value parameter is crossinline in one declaration and not crossinline in the other")
 
     // Reason is not really required because the renderer for ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT doesn't use it, but it is here just in case.
-    object IgnorabilityIsDifferent : ExpectActualIncompatibility<Nothing>("callable declarations have different ignorability flags")
+    object IgnorabilityIsDifferent : ExpectActualIncompatibility<Nothing>("") {
+        override val reason: Nothing get() = error("This incompatibility should be reported with ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT diagnostic")
+    }
 
     // Functions
     object FunctionModifiersDifferent : ExpectActualIncompatibility<Nothing>("the modifiers are different (suspend)")

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ open class BaseFoo {`
`29`	`29`
`30`	`30`	`// FILE: jvm.kt`
`31`	`31`
`32`		`-actual class <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; 'fun x(): String' defined in 'BaseFoo'"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; 'fun ign(): String' defined in 'BaseFoo'"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; 'constructor(): Foo' defined in 'Foo'")!>Foo<!> : BaseFoo() {`
	`32`	`+actual class <!ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun x(): String' defined in 'Foo'; must-use; 'fun x(): String' defined in 'BaseFoo'; ignorable"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect fun ign(): String' defined in 'Foo'; ignorable; 'fun ign(): String' defined in 'BaseFoo'; must-use"), ACTUAL_IGNORABILITY_NOT_MATCH_EXPECT("'expect constructor(): Foo' defined in 'Foo'; must-use; 'constructor(): Foo' defined in 'Foo'; unspecified (implicitly ignorable)")!>Foo<!> : BaseFoo() {`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`fun main() {`