[FIR] Implement EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE

^KT-60367 Fixed
KT review: https://jetbrains.team/p/kt/reviews/14064/timeline
IJ review: https://jetbrains.team/p/ij/reviews/124657/timeline

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -3042,6 +3042,13 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE) { firDiagnostic ->
+        ExpectAndActualInTheSameModuleImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a),
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
     add(FirErrors.METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE) { firDiagnostic ->
         MethodOfAnyImplementedInInterfaceImpl(
             firDiagnostic as KtPsiDiagnostic,

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -2151,6 +2151,11 @@ sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         val conflictingDeclarations: List<KtSymbol>
     }
 
+    interface ExpectAndActualInTheSameModule : KtFirDiagnostic<KtNamedDeclaration> {
+        override val diagnosticClass get() = ExpectAndActualInTheSameModule::class
+        val declaration: KtSymbol
+    }
+
     interface MethodOfAnyImplementedInInterface : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = MethodOfAnyImplementedInInterface::class
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -2577,6 +2577,12 @@ internal class PackageOrClassifierRedeclarationImpl(
     token: KtLifetimeToken,
 ) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.PackageOrClassifierRedeclaration
 
+internal class ExpectAndActualInTheSameModuleImpl(
+    override val declaration: KtSymbol,
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExpectAndActualInTheSameModule
+
 internal class MethodOfAnyImplementedInInterfaceImpl(
     firDiagnostic: KtPsiDiagnostic,
     token: KtLifetimeToken,

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java

@@ -24854,6 +24854,24 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia
                 runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreInBeta_suppressWarningWithLv.kt");
             }
 
+            @Test
+            @TestMetadata("expectActualInTheSameModule.kt")
+            public void testExpectActualInTheSameModule() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModule.kt");
+            }
+
+            @Test
+            @TestMetadata("expectActualInTheSameModuleDifferentFiles.kt")
+            public void testExpectActualInTheSameModuleDifferentFiles() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.kt");
+            }
+
+            @Test
+            @TestMetadata("expectActualMainInTheSameModuleDifferentFiles.kt")
+            public void testExpectActualMainInTheSameModuleDifferentFiles() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualMainInTheSameModuleDifferentFiles.kt");
+            }
+
             @Test
             @TestMetadata("expectDataObject.kt")
             public void testExpectDataObject() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java

@@ -24854,6 +24854,24 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated
                 runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreInBeta_suppressWarningWithLv.kt");
             }
 
+            @Test
+            @TestMetadata("expectActualInTheSameModule.kt")
+            public void testExpectActualInTheSameModule() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModule.kt");
+            }
+
+            @Test
+            @TestMetadata("expectActualInTheSameModuleDifferentFiles.kt")
+            public void testExpectActualInTheSameModuleDifferentFiles() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.kt");
+            }
+
+            @Test
+            @TestMetadata("expectActualMainInTheSameModuleDifferentFiles.kt")
+            public void testExpectActualMainInTheSameModuleDifferentFiles() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualMainInTheSameModuleDifferentFiles.kt");
+            }
+
             @Test
             @TestMetadata("expectDataObject.kt")
             public void testExpectDataObject() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated.java

@@ -139,6 +139,24 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst
         runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreInBeta_suppressWarningWithLv.kt");
     }
 
+    @Test
+    @TestMetadata("expectActualInTheSameModule.kt")
+    public void testExpectActualInTheSameModule() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModule.kt");
+    }
+
+    @Test
+    @TestMetadata("expectActualInTheSameModuleDifferentFiles.kt")
+    public void testExpectActualInTheSameModuleDifferentFiles() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.kt");
+    }
+
+    @Test
+    @TestMetadata("expectActualMainInTheSameModuleDifferentFiles.kt")
+    public void testExpectActualMainInTheSameModuleDifferentFiles() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualMainInTheSameModuleDifferentFiles.kt");
+    }
+
     @Test
     @TestMetadata("expectDataObject.kt")
     public void testExpectDataObject() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendMPPDiagnosticsWithPsiTestGenerated.java

@@ -139,6 +139,24 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi
         runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreInBeta_suppressWarningWithLv.kt");
     }
 
+    @Test
+    @TestMetadata("expectActualInTheSameModule.kt")
+    public void testExpectActualInTheSameModule() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModule.kt");
+    }
+
+    @Test
+    @TestMetadata("expectActualInTheSameModuleDifferentFiles.kt")
+    public void testExpectActualInTheSameModuleDifferentFiles() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.kt");
+    }
+
+    @Test
+    @TestMetadata("expectActualMainInTheSameModuleDifferentFiles.kt")
+    public void testExpectActualMainInTheSameModuleDifferentFiles() throws Exception {
+        runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualMainInTheSameModuleDifferentFiles.kt");
+    }
+
     @Test
     @TestMetadata("expectDataObject.kt")
     public void testExpectDataObject() throws Exception {

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -1079,6 +1079,9 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
         val PACKAGE_OR_CLASSIFIER_REDECLARATION by error<KtNamedDeclaration>(PositioningStrategy.ACTUAL_DECLARATION_NAME) {
             parameter<Collection<Symbol>>("conflictingDeclarations")
         }
+        val EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE by error<KtNamedDeclaration>(PositioningStrategy.ACTUAL_DECLARATION_NAME) {
+            parameter<Symbol>("declaration")
+        }
         val METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE by error<PsiElement>()
     }
 

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -552,6 +552,7 @@ object FirErrors {
     val CONFLICTING_OVERLOADS: KtDiagnosticFactory1<Collection<FirBasedSymbol<*>>> by error1<PsiElement, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT)
     val REDECLARATION: KtDiagnosticFactory1<Collection<FirBasedSymbol<*>>> by error1<KtNamedDeclaration, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.NAME_IDENTIFIER)
     val PACKAGE_OR_CLASSIFIER_REDECLARATION: KtDiagnosticFactory1<Collection<FirBasedSymbol<*>>> by error1<KtNamedDeclaration, Collection<FirBasedSymbol<*>>>(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME)
+    val EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE: KtDiagnosticFactory1<FirBasedSymbol<*>> by error1<KtNamedDeclaration, FirBasedSymbol<*>>(SourceElementPositioningStrategies.ACTUAL_DECLARATION_NAME)
     val METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE: KtDiagnosticFactory0 by error0<PsiElement>()
 
     // Invalid local declarations

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirNonSuppressibleErrorNames.kt

@@ -361,6 +361,7 @@ val FIR_NON_SUPPRESSIBLE_ERROR_NAMES: Set<String> = setOf(
     "CONFLICTING_OVERLOADS",
     "REDECLARATION",
     "PACKAGE_OR_CLASSIFIER_REDECLARATION",
+    "EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE",
     "METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE",
     "LOCAL_OBJECT_NOT_ALLOWED",
     "LOCAL_INTERFACE_NOT_ALLOWED",

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConflictsHelpers.kt

@@ -93,7 +93,7 @@ private val FirBasedSymbol<*>.resolvedStatus
         else -> null
     }
 
-private fun isExpectAndActual(declaration1: FirBasedSymbol<*>, declaration2: FirBasedSymbol<*>): Boolean {
+internal fun isExpectAndActual(declaration1: FirBasedSymbol<*>, declaration2: FirBasedSymbol<*>): Boolean {
     val status1 = declaration1.resolvedStatus ?: return false
     val status2 = declaration2.resolvedStatus ?: return false
     return (status1.isExpect && status2.isActual) || (status1.isActual && status2.isExpect)
@@ -496,7 +496,7 @@ private fun FirDeclarationCollector<*>.areNonConflictingCallables(
     declaration: FirBasedSymbol<*>,
     conflicting: FirBasedSymbol<*>,
 ): Boolean {
-    if (isExpectAndActual(declaration, conflicting)) return true
+    if (isExpectAndActual(declaration, conflicting) && declaration.moduleData != conflicting.moduleData) return true
 
     val declarationIsLowPriority = hasLowPriorityAnnotation(declaration.annotations)
     val conflictingIsLowPriority = hasLowPriorityAnnotation(conflicting.annotations)

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

@@ -90,19 +90,22 @@ object FirConflictsDeclarationChecker : FirBasicDeclarationChecker(MppCheckerKin
                 conflictingDeclaration.isPrimaryConstructor && symbols.all { it.isPrimaryConstructor }
             ) return@forEach
 
-            val factory =
-                if (conflictingDeclaration is FirNamedFunctionSymbol || conflictingDeclaration is FirConstructorSymbol) {
-                    FirErrors.CONFLICTING_OVERLOADS
-                } else if (conflictingDeclaration is FirClassLikeSymbol<*> &&
-                    conflictingDeclaration.getContainingClassSymbol(context.session) == null &&
-                    symbols.any { it is FirClassLikeSymbol<*> }
-                ) {
-                    FirErrors.PACKAGE_OR_CLASSIFIER_REDECLARATION
-                } else {
-                    FirErrors.REDECLARATION
+            when {
+                symbols.singleOrNull()?.let { isExpectAndActual(conflictingDeclaration, it) } == true -> {
+                    reporter.reportOn(source, FirErrors.EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE, conflictingDeclaration, context)
                 }
-
-            reporter.reportOn(source, factory, symbols, context)
+                conflictingDeclaration is FirNamedFunctionSymbol || conflictingDeclaration is FirConstructorSymbol -> {
+                    reporter.reportOn(source, FirErrors.CONFLICTING_OVERLOADS, symbols, context)
+                }
+                conflictingDeclaration is FirClassLikeSymbol<*> &&
+                        conflictingDeclaration.getContainingClassSymbol(context.session) == null &&
+                        symbols.any { it is FirClassLikeSymbol<*> } -> {
+                    reporter.reportOn(source, FirErrors.PACKAGE_OR_CLASSIFIER_REDECLARATION, symbols, context)
+                }
+                else -> {
+                    reporter.reportOn(source, FirErrors.REDECLARATION, symbols, context)
+                }
+            }
         }
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt

@@ -501,6 +501,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PACKAGE_CANNOT_BE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PACKAGE_OR_CLASSIFIER_REDECLARATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PLATFORM_CLASS_MAPPED_TO_KOTLIN
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPILER_REQUIRED_ANNOTATION_AMBIGUITY
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.POTENTIALLY_NON_REPORTED_ANNOTATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRE_RELEASE_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED
@@ -1800,6 +1801,8 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
         map.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", SYMBOLS)
         map.put(REDECLARATION, "Conflicting declarations: {0}", SYMBOLS)
         map.put(PACKAGE_OR_CLASSIFIER_REDECLARATION, "Redeclaration: {0}", SYMBOLS)
+        map.put(EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE, "{0}: expect and corresponding actual are declared in the same module", DECLARATION_NAME)
+
         map.put(METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE, "Interfaces cannot implement a method of 'Any'.")
 
         // Invalid local declarations

compiler/testData/cli/metadata/inheritorOfExpectSealedClass.out

@@ -1,4 +1,10 @@
+compiler/testData/cli/metadata/inheritorOfExpectSealedClass/common-1.kt:1:21: error: base: expect and corresponding actual are declared in the same module
+expect sealed class Base
+                    ^
 compiler/testData/cli/metadata/inheritorOfExpectSealedClass/common-2.kt:1:21: error: 'actual class Base : Any' has no corresponding expected declaration
+actual sealed class Base
+                    ^
+compiler/testData/cli/metadata/inheritorOfExpectSealedClass/common-2.kt:1:21: error: base: expect and corresponding actual are declared in the same module
 actual sealed class Base
                     ^
 compiler/testData/cli/metadata/inheritorOfExpectSealedClass/common-3.kt:1:17: error: unresolved reference '<init>'.

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

@@ -0,0 +1,11 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>A<!>
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>A<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+expect class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>B<!>
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>B<!>

compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModule.kt

@@ -0,0 +1,11 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class A<!>
+actual <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class A<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+expect <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class B<!>
+actual <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class B<!>

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

@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class A
+
+// FILE: common2.kt
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>A<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+expect class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>B<!>
+
+// FILE: jvm2.kt
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>B<!>

compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.kt

@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class A<!>
+
+// FILE: common2.kt
+actual <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class A<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+expect <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class B<!>
+
+// FILE: jvm2.kt
+actual <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>class B<!>

compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.ll.kt

@@ -0,0 +1,15 @@
+// MODULE: m1-common
+// FILE: common.kt
+
+expect class A
+
+// FILE: common2.kt
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>A<!>
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+
+expect class B
+
+// FILE: jvm2.kt
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>B<!>

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

@@ -0,0 +1,13 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect fun <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>()
+
+// FILE: common2.kt
+actual fun <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>() {}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+expect fun <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>()
+
+// FILE: jvm2.kt
+actual fun <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>() {}

compiler/testData/diagnostics/tests/multiplatform/expectActualMainInTheSameModuleDifferentFiles.kt

@@ -0,0 +1,13 @@
+// MODULE: m1-common
+// FILE: common.kt
+expect fun <!AMBIGUOUS_ACTUALS{JVM}, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>()
+
+// FILE: common2.kt
+actual fun <!AMBIGUOUS_EXPECTS{JVM}, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE{JVM}!>main<!>() {}
+
+// MODULE: m1-jvm()()(m1-common)
+// FILE: jvm.kt
+expect fun <!AMBIGUOUS_ACTUALS, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>()
+
+// FILE: jvm2.kt
+actual fun <!AMBIGUOUS_EXPECTS, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>main<!>() {}

compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModule.fir.kt

@@ -1,67 +1,67 @@
 // MODULE: common
 // TARGET_PLATFORM: Common
 
-expect class CommonClass {
+expect class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>CommonClass<!> {
     fun memberFun()
     val memberProp: Int
     class Nested
     inner class Inner
 }
-actual class <!ACTUAL_WITHOUT_EXPECT!>CommonClass<!> {
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>CommonClass<!> {
     actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
     actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
     actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
     actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
 }
 
-expect fun commonFun()
-actual fun <!ACTUAL_WITHOUT_EXPECT!>commonFun<!>() {}
+expect fun <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>commonFun<!>()
+actual fun <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>commonFun<!>() {}
 
-expect val commonProperty: String
-actual val <!ACTUAL_WITHOUT_EXPECT!>commonProperty<!>: String
+expect val <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>commonProperty<!>: String
+actual val <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>commonProperty<!>: String
     get() = "hello"
 
 // MODULE: intermediate()()(common)
 // TARGET_PLATFORM: Common
 
-expect class IntermediateClass {
+expect class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>IntermediateClass<!> {
     fun memberFun()
     val memberProp: Int
     class Nested
     inner class Inner
 }
-actual class <!ACTUAL_WITHOUT_EXPECT!>IntermediateClass<!> {
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>IntermediateClass<!> {
     actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
     actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
     actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
     actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
 }
 
-expect fun intermediateFun()
-actual fun <!ACTUAL_WITHOUT_EXPECT!>intermediateFun<!>() {}
+expect fun <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>intermediateFun<!>()
+actual fun <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>intermediateFun<!>() {}
 
-expect val intermediateProperty: String
-actual val <!ACTUAL_WITHOUT_EXPECT!>intermediateProperty<!>: String
+expect val <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>intermediateProperty<!>: String
+actual val <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>intermediateProperty<!>: String
     get() = "hello"
 
 // MODULE: main()()(intermediate)
 
-expect class PlatformClass {
+expect class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>PlatformClass<!> {
     fun memberFun()
     val memberProp: Int
     class Nested
     inner class Inner
 }
-actual class <!ACTUAL_WITHOUT_EXPECT!>PlatformClass<!> {
+actual class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>PlatformClass<!> {
     actual fun <!ACTUAL_WITHOUT_EXPECT!>memberFun<!>() {}
     actual val <!ACTUAL_WITHOUT_EXPECT!>memberProp<!>: Int = 42
     actual class <!ACTUAL_WITHOUT_EXPECT!>Nested<!>
     actual inner class <!ACTUAL_WITHOUT_EXPECT!>Inner<!>
 }
 
-expect fun platformFun()
-actual fun <!ACTUAL_WITHOUT_EXPECT!>platformFun<!>() {}
+expect fun <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>platformFun<!>()
+actual fun <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>platformFun<!>() {}
 
-expect val platformProperty: String
-actual val <!ACTUAL_WITHOUT_EXPECT!>platformProperty<!>: String
+expect val <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>platformProperty<!>: String
+actual val <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>platformProperty<!>: String
     get() = "hello"

compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/expectAndActualInTheSameModuleIncompatibilities.fir.kt

@@ -13,10 +13,10 @@ val callableKind: Int = 1
 expect fun <T> typeParameterCount()
 fun typeParameterCount() {}
 
-expect enum class EnumEntries {
+expect enum class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>EnumEntries<!> {
     ONE, TWO;
 }
-actual enum class <!ACTUAL_WITHOUT_EXPECT!>EnumEntries<!> {
+actual enum class <!ACTUAL_WITHOUT_EXPECT, EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>EnumEntries<!> {
     ONE;
 }
 

compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.fir.kt

@@ -1,6 +1,6 @@
 <!NOT_A_MULTIPLATFORM_COMPILATION!>expect<!> fun foo1()
 <!NOT_A_MULTIPLATFORM_COMPILATION!>expect<!> val bar1 = <!EXPECTED_PROPERTY_INITIALIZER!>42<!>
-<!NOT_A_MULTIPLATFORM_COMPILATION!>expect<!> class ImplicitExpect {
+<!NOT_A_MULTIPLATFORM_COMPILATION!>expect<!> class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>ImplicitExpect<!> {
     fun foo()
     val x: Int
     class Inner
@@ -16,7 +16,7 @@
 <!MUST_BE_INITIALIZED!><!NOT_A_MULTIPLATFORM_COMPILATION!>actual<!> val bar2: Int<!>
 <!NOT_A_MULTIPLATFORM_COMPILATION!>actual<!> interface Baz2
 
-<!NOT_A_MULTIPLATFORM_COMPILATION!>actual<!> class ImplicitExpect {
+<!NOT_A_MULTIPLATFORM_COMPILATION!>actual<!> class <!EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE!>ImplicitExpect<!> {
     <!NOT_A_MULTIPLATFORM_COMPILATION!>actual<!> fun foo() {
     }
     <!NOT_A_MULTIPLATFORM_COMPILATION!>actual<!> val x: Int = 0

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -24854,6 +24854,24 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                 runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualClassesAreInBeta_suppressWarningWithLv.kt");
             }
 
+            @Test
+            @TestMetadata("expectActualInTheSameModule.kt")
+            public void testExpectActualInTheSameModule() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModule.kt");
+            }
+
+            @Test
+            @TestMetadata("expectActualInTheSameModuleDifferentFiles.kt")
+            public void testExpectActualInTheSameModuleDifferentFiles() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualInTheSameModuleDifferentFiles.kt");
+            }
+
+            @Test
+            @TestMetadata("expectActualMainInTheSameModuleDifferentFiles.kt")
+            public void testExpectActualMainInTheSameModuleDifferentFiles() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/multiplatform/expectActualMainInTheSameModuleDifferentFiles.kt");
+            }
+
             @Test
             @TestMetadata("expectDataObject.kt")
             public void testExpectDataObject() throws Exception {