[FE1.0] Fix false reporting of non-matching annotations in IDE...

...when typealiased expect class used in class literal.

^KTIJ-26700 Fixed

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

@@ -1419,6 +1419,12 @@ public class FirOldFrontendMPPDiagnosticsWithLightTreeTestGenerated extends Abst
                 public void testTypealiasedAnnotationAsArgument() throws Exception {
                     runTest("compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAnnotationAsArgument.kt");
                 }
+
+                @Test
+                @TestMetadata("typealiasedAsKClassArg.kt")
+                public void testTypealiasedAsKClassArg() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAsKClassArg.kt");
+                }
             }
         }
     }

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

@@ -1419,6 +1419,12 @@ public class FirOldFrontendMPPDiagnosticsWithPsiTestGenerated extends AbstractFi
                 public void testTypealiasedAnnotationAsArgument() throws Exception {
                     runTest("compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAnnotationAsArgument.kt");
                 }
+
+                @Test
+                @TestMetadata("typealiasedAsKClassArg.kt")
+                public void testTypealiasedAsKClassArg() throws Exception {
+                    runTest("compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAsKClassArg.kt");
+                }
             }
         }
     }

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

@@ -389,13 +389,17 @@ class ClassicExpectActualMatchingContext(
                 return classDescriptor
             }
             val classId = classDescriptor.classId
-            // For IDE composite module analysis, when actual annotation may differ
-            val platformDescriptor = platformModule.findClassifierAcrossModuleDependencies(classId)
-            return when (platformDescriptor) {
-                is ClassDescriptor -> platformDescriptor
-                is TypeAliasDescriptor -> platformDescriptor.classDescriptor ?: classDescriptor
-                else -> classDescriptor
-            }
+            return findExpandedExpectClassInPlatformModule(classId) ?: classDescriptor
+        }
+    }
+
+    // For IDE composite module analysis, when actual class may differ
+    internal fun findExpandedExpectClassInPlatformModule(originalClassId: ClassId): ClassDescriptor? {
+        val classifier = platformModule.findClassifierAcrossModuleDependencies(originalClassId)
+        return when (classifier) {
+            is TypeAliasDescriptor -> classifier.classDescriptor
+            is ClassDescriptor -> classifier
+            else -> null
         }
     }
 

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

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.resolve.multiplatform
 
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualCollectionArgumentsCompatibilityCheckStrategy
-import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
+import org.jetbrains.kotlin.resolve.constants.KClassValue
 
-internal fun ExpectActualMatchingContext<*>.areExpressionConstValuesEqual(
+internal fun ClassicExpectActualMatchingContext.areExpressionConstValuesEqual(
     expectValue: Any?,
     actualValue: Any?,
     collectionArgumentsCompatibilityCheckStrategy: ExpectActualCollectionArgumentsCompatibilityCheckStrategy,
@@ -36,6 +36,16 @@ internal fun ExpectActualMatchingContext<*>.areExpressionConstValuesEqual(
                 areExpressionConstValuesEqual(f, s, collectionArgumentsCompatibilityCheckStrategy)
             }
         }
+        expectValue is KClassValue.Value.NormalClass && actualValue is KClassValue.Value.NormalClass -> {
+            val expectClassIdOriginal = expectValue.classId
+            val expectClassIdPlatform = findExpandedExpectClassInPlatformModule(expectClassIdOriginal)?.classId
+            val expectValueCopy = expectValue.copy(
+                value = expectValue.value.copy(
+                    classId = expectClassIdPlatform ?: expectClassIdOriginal
+                )
+            )
+            expectValueCopy == actualValue
+        }
         else -> expectValue == actualValue
     }
 }

compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAsKClassArg.kt

@@ -0,0 +1,23 @@
+// FIR_IDENTICAL
+// WITH_STDLIB
+// MODULE: common
+expect class Typealiased
+
+annotation class Ann(val p: kotlin.reflect.KClass<*>)
+
+@Ann(Typealiased::class)
+expect fun test()
+
+@Ann(Array<Typealiased>::class)
+expect fun testInArray()
+
+// MODULE: main()()(common)
+class TypealiasedImpl
+
+actual typealias Typealiased = TypealiasedImpl
+
+@Ann(Typealiased::class)
+actual fun test() {}
+
+@Ann(Array<Typealiased>::class)
+actual fun testInArray() {}

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

@@ -24206,6 +24206,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                         public void testTypealiasedAnnotationAsArgument() throws Exception {
                             runTest("compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAnnotationAsArgument.kt");
                         }
+
+                        @Test
+                        @TestMetadata("typealiasedAsKClassArg.kt")
+                        public void testTypealiasedAsKClassArg() throws Exception {
+                            runTest("compiler/testData/diagnostics/tests/multiplatform/hmpp/multiplatformCompositeAnalysis/annotationMatching/typealiasedAsKClassArg.kt");
+                        }
                     }
                 }
             }