[MPP] Permit const actual properties for non-const expects

It's safe as not having const is more restrictive, therefore can be
allowed in common. Otherwise, it's not possible to declare an expect
declaration for a platform property with `const` modifier in common

KT-18856

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualResolver.kt

@@ -536,14 +536,16 @@ object FirExpectActualResolver {
         return ExpectActualCompatibility.Compatible
     }
 
-    private fun areCompatibleProperties(a: FirPropertySymbol, b: FirPropertySymbol): ExpectActualCompatibility<FirBasedSymbol<*>> {
-        if (!equalBy(a, b) { p -> p.isVar }) {
-            return ExpectActualCompatibility.Incompatible.PropertyKind
+    private fun areCompatibleProperties(
+        expected: FirPropertySymbol,
+        actual: FirPropertySymbol,
+    ): ExpectActualCompatibility<FirBasedSymbol<*>> {
+        return when {
+            !equalBy(expected, actual) { p -> p.isVar } -> ExpectActualCompatibility.Incompatible.PropertyKind
+            !equalBy(expected, actual) { p -> p.isLateInit } -> ExpectActualCompatibility.Incompatible.PropertyLateinitModifier
+            expected.isConst && !actual.isConst -> ExpectActualCompatibility.Incompatible.PropertyConstModifier
+            else -> ExpectActualCompatibility.Compatible
         }
-        if (!equalBy(a, b) { p -> listOf(p.isConst, p.isLateInit) }) {
-            return ExpectActualCompatibility.Incompatible.PropertyModifiers
-        }
-        return ExpectActualCompatibility.Compatible
     }
 
     // ---------------------------------------- Utils ----------------------------------------

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/ClassicPositioningStrategies.kt

@@ -88,7 +88,9 @@ object ClassicPositioningStrategies {
                     }
                     ExpectActualCompatibility.Incompatible.FunctionModifiersDifferent,
                     ExpectActualCompatibility.Incompatible.FunctionModifiersNotSubset,
-                    ExpectActualCompatibility.Incompatible.PropertyModifiers, ExpectActualCompatibility.Incompatible.ClassModifiers -> {
+                    ExpectActualCompatibility.Incompatible.PropertyLateinitModifier,
+                    ExpectActualCompatibility.Incompatible.PropertyConstModifier,
+                    ExpectActualCompatibility.Incompatible.ClassModifiers -> {
                         element.modifierList
                     }
                     ExpectActualCompatibility.Incompatible.PropertyKind -> {

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt

@@ -56,7 +56,8 @@ sealed class ExpectActualCompatibility<out D> {
         // Properties
 
         object PropertyKind : Incompatible<Nothing>("property kinds are different (val vs var)")
-        object PropertyModifiers : Incompatible<Nothing>("modifiers are different (const, lateinit)")
+        object PropertyLateinitModifier : Incompatible<Nothing>("modifiers are different (lateinit)")
+        object PropertyConstModifier : Incompatible<Nothing>("modifiers are different (const)")
 
         // Classifiers
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt

@@ -360,11 +360,16 @@ object ExpectedActualResolver {
         return Compatible
     }
 
-    private fun areCompatibleProperties(a: PropertyDescriptor, b: PropertyDescriptor): ExpectActualCompatibility<MemberDescriptor> {
-        if (!equalBy(a, b) { p -> p.isVar }) return Incompatible.PropertyKind
-        if (!equalBy(a, b) { p -> listOf(p.isConst, p.isLateInit) }) return Incompatible.PropertyModifiers
-
-        return Compatible
+    private fun areCompatibleProperties(
+        expected: PropertyDescriptor,
+        actual: PropertyDescriptor,
+    ): ExpectActualCompatibility<MemberDescriptor> {
+        return when {
+            !equalBy(expected, actual) { p -> p.isVar } -> Incompatible.PropertyKind
+            !equalBy(expected, actual) { p -> p.isLateInit } -> Incompatible.PropertyLateinitModifier
+            expected.isConst && !actual.isConst -> Incompatible.PropertyConstModifier
+            else -> Compatible
+        }
     }
 
     private fun areCompatibleClassifiers(a: ClassDescriptor, other: ClassifierDescriptor): ExpectActualCompatibility<MemberDescriptor> {

compiler/testData/diagnostics/testsWithMultiplatformCompositeAnalysis/constVals/nonConstExpectConstActual.kt

@@ -46,11 +46,11 @@ class ConstImpl {
 // actuals
 
 actual typealias NonConstNonConst = NonConstImpl
-actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>NonConstConst<!> = ConstImpl
+actual typealias NonConstConst = ConstImpl
 actual typealias <!NO_ACTUAL_CLASS_MEMBER_FOR_EXPECTED_CLASS!>ConstNonConst<!> = NonConstImpl
 actual typealias ConstConst = ConstImpl
 
 actual val NonConstNonConstTl: Int get() = 42
-<!ACTUAL_WITHOUT_EXPECT!>actual const<!> val NonConstConstTl: Int = 42
+actual const val NonConstConstTl: Int = 42
 <!ACTUAL_WITHOUT_EXPECT!>actual<!> val ConstNonConstTl: Int get() = 42
 actual const val ConstConstTl: Int = 42