2/2 Extract K1 KMP matcher in its own subsystem. Fix compilation errors

2023-10-04 16:55:04 +02:00
parent cc70f78027
commit 43c97077eb
16 changed files with 224 additions and 274 deletions
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.modalityModifier
 import org.jetbrains.kotlin.psi.psiUtil.visibilityModifier
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility

 object ClassicPositioningStrategies {
    @JvmField
@@ -30,14 +30,14 @@ object ClassicPositioningStrategies {
        }

    // TODO: move to specific strategies
-    private val DiagnosticMarker.firstIncompatibility: ExpectActualCompatibility.Incompatible<MemberDescriptor>?
+    private val DiagnosticMarker.firstIncompatibility: K1ExpectActualCompatibility.Incompatible<MemberDescriptor>?
        get() {
            @Suppress("UNCHECKED_CAST")
            val map = when (factoryName) {
                Errors.NO_ACTUAL_FOR_EXPECT.name -> (this as DiagnosticWithParameters3Marker<*, *, *>).c
                Errors.ACTUAL_WITHOUT_EXPECT.name -> (this as DiagnosticWithParameters2Marker<*, *>).b
                else -> null
-            } as? Map<ExpectActualCompatibility.Incompatible<MemberDescriptor>, Collection<MemberDescriptor>> ?: return null
+            } as? Map<K1ExpectActualCompatibility.Incompatible<MemberDescriptor>, Collection<MemberDescriptor>> ?: return null
            return map.keys.firstOrNull()
        }

@@ -49,9 +49,9 @@ object ClassicPositioningStrategies {
                val callableDeclaration = element as? KtCallableDeclaration
                val incompatibility = diagnostic.firstIncompatibility
                return when (incompatibility) {
-                    null, is ExpectActualCompatibility.Incompatible.ClassScopes,
-                    ExpectActualCompatibility.Incompatible.EnumEntries -> null
-                    ExpectActualCompatibility.Incompatible.ClassKind -> {
+                    null, is K1ExpectActualCompatibility.Incompatible.ClassScopes,
+                    K1ExpectActualCompatibility.Incompatible.EnumEntries -> null
+                    K1ExpectActualCompatibility.Incompatible.ClassKind -> {
                        val startElement =
                            element.modifierList?.getModifier(KtTokens.ENUM_KEYWORD)
                                ?: element.modifierList?.getModifier(KtTokens.ANNOTATION_KEYWORD)
@@ -64,53 +64,53 @@ object ClassicPositioningStrategies {
                            endElement
                        }
                    }
-                    ExpectActualCompatibility.Incompatible.TypeParameterNames,
-                    ExpectActualCompatibility.Incompatible.FunctionTypeParameterCount,
-                    ExpectActualCompatibility.Incompatible.ClassTypeParameterCount,
-                    ExpectActualCompatibility.Incompatible.FunctionTypeParameterUpperBounds,
-                    ExpectActualCompatibility.Incompatible.ClassTypeParameterUpperBounds,
-                    ExpectActualCompatibility.Incompatible.TypeParameterVariance,
-                    ExpectActualCompatibility.Incompatible.TypeParameterReified -> {
+                    K1ExpectActualCompatibility.Incompatible.TypeParameterNames,
+                    K1ExpectActualCompatibility.Incompatible.FunctionTypeParameterCount,
+                    K1ExpectActualCompatibility.Incompatible.ClassTypeParameterCount,
+                    K1ExpectActualCompatibility.Incompatible.FunctionTypeParameterUpperBounds,
+                    K1ExpectActualCompatibility.Incompatible.ClassTypeParameterUpperBounds,
+                    K1ExpectActualCompatibility.Incompatible.TypeParameterVariance,
+                    K1ExpectActualCompatibility.Incompatible.TypeParameterReified -> {
                        (element as? KtTypeParameterListOwner)?.typeParameterList
                    }
-                    ExpectActualCompatibility.Incompatible.CallableKind -> {
+                    K1ExpectActualCompatibility.Incompatible.CallableKind -> {
                        (callableDeclaration as? KtNamedFunction)?.funKeyword
                            ?: (callableDeclaration as? KtProperty)?.valOrVarKeyword
                    }
-                    ExpectActualCompatibility.Incompatible.ParameterShape -> {
+                    K1ExpectActualCompatibility.Incompatible.ParameterShape -> {
                        callableDeclaration?.let { it.receiverTypeReference ?: it.valueParameterList }
                    }
-                    ExpectActualCompatibility.Incompatible.ParameterCount, ExpectActualCompatibility.Incompatible.ParameterTypes,
-                    ExpectActualCompatibility.Incompatible.ParameterNames, ExpectActualCompatibility.Incompatible.ValueParameterVararg,
-                    ExpectActualCompatibility.Incompatible.ActualFunctionWithDefaultParameters,
-                    ExpectActualCompatibility.Incompatible.ValueParameterNoinline,
-                    ExpectActualCompatibility.Incompatible.ValueParameterCrossinline -> {
+                    K1ExpectActualCompatibility.Incompatible.ParameterCount, K1ExpectActualCompatibility.Incompatible.ParameterTypes,
+                    K1ExpectActualCompatibility.Incompatible.ParameterNames, K1ExpectActualCompatibility.Incompatible.ValueParameterVararg,
+                    K1ExpectActualCompatibility.Incompatible.ActualFunctionWithDefaultParameters,
+                    K1ExpectActualCompatibility.Incompatible.ValueParameterNoinline,
+                    K1ExpectActualCompatibility.Incompatible.ValueParameterCrossinline -> {
                        callableDeclaration?.valueParameterList
                    }
-                    ExpectActualCompatibility.Incompatible.ReturnType -> {
+                    K1ExpectActualCompatibility.Incompatible.ReturnType -> {
                        callableDeclaration?.typeReference
                    }
-                    ExpectActualCompatibility.Incompatible.FunctionModifiersDifferent,
-                    ExpectActualCompatibility.Incompatible.FunctionModifiersNotSubset,
-                    ExpectActualCompatibility.Incompatible.PropertyLateinitModifier,
-                    ExpectActualCompatibility.Incompatible.PropertyConstModifier,
-                    ExpectActualCompatibility.Incompatible.ClassModifiers,
-                    ExpectActualCompatibility.Incompatible.FunInterfaceModifier -> {
+                    K1ExpectActualCompatibility.Incompatible.FunctionModifiersDifferent,
+                    K1ExpectActualCompatibility.Incompatible.FunctionModifiersNotSubset,
+                    K1ExpectActualCompatibility.Incompatible.PropertyLateinitModifier,
+                    K1ExpectActualCompatibility.Incompatible.PropertyConstModifier,
+                    K1ExpectActualCompatibility.Incompatible.ClassModifiers,
+                    K1ExpectActualCompatibility.Incompatible.FunInterfaceModifier -> {
                        element.modifierList
                    }
-                    ExpectActualCompatibility.Incompatible.PropertyKind -> {
+                    K1ExpectActualCompatibility.Incompatible.PropertyKind -> {
                        element.node.findChildByType(PositioningStrategies.propertyKindTokens)?.psi
                    }
-                    ExpectActualCompatibility.Incompatible.Supertypes -> {
+                    K1ExpectActualCompatibility.Incompatible.Supertypes -> {
                        (element as? KtClassOrObject)?.getSuperTypeList()
                    }
-                    ExpectActualCompatibility.Incompatible.Modality -> {
+                    K1ExpectActualCompatibility.Incompatible.Modality -> {
                        element.modalityModifier()
                    }
-                    ExpectActualCompatibility.Incompatible.Visibility -> {
+                    K1ExpectActualCompatibility.Incompatible.Visibility -> {
                        element.visibilityModifier()
                    }
-                    ExpectActualCompatibility.Incompatible.PropertySetterVisibility -> {
+                    K1ExpectActualCompatibility.Incompatible.PropertySetterVisibility -> {
                        (element as? KtProperty)?.setter?.modifierList
                    }
                }?.let { markElement(it) } ?: ACTUAL_DECLARATION_NAME.mark(element)
@@ -35,8 +35,8 @@ import org.jetbrains.kotlin.resolve.calls.tower.WrongResolutionToClassifier;
 import org.jetbrains.kotlin.resolve.calls.util.BuilderLambdaLabelingInfo;
 import org.jetbrains.kotlin.resolve.deprecation.DescriptorBasedDeprecationInfo;
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType;
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.Incompatible;
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMemberDiff;
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility.Incompatible;
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualMemberDiff;
 import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData;
 import org.jetbrains.kotlin.types.KotlinType;

@@ -837,26 +837,26 @@ public interface Errors {

    DiagnosticFactory1<KtNamedDeclaration, MemberDescriptor> EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);

-    DiagnosticFactory3<KtClassLikeDeclaration, ClassifierDescriptorWithTypeParameters, Set<ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>, ClassDescriptor>
+    DiagnosticFactory3<KtClassLikeDeclaration, ClassifierDescriptorWithTypeParameters, Set<K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>, ClassDescriptor>
            ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_MEMBERS_AS_NON_FINAL_EXPECT_CLASSIFIER_WARNING =
            DiagnosticFactory3.create(WARNING, DECLARATION_NAME);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            NON_ACTUAL_MEMBER_DECLARED_IN_EXPECT_NON_FINAL_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            RETURN_TYPE_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, DECLARATION_RETURN_TYPE);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            MODALITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, MODALITY_MODIFIER);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            VISIBILITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, VISIBILITY_MODIFIER);
-    DiagnosticFactory1<KtPropertyAccessor, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtPropertyAccessor, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            SETTER_VISIBILITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, VISIBILITY_MODIFIER);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            PARAMETER_NAME_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, DECLARATION_NAME);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            PROPERTY_KIND_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, VAL_OR_VAR_NODE);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            LATEINIT_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, LATEINIT_MODIFIER);
-    DiagnosticFactory1<KtCallableDeclaration, ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
+    DiagnosticFactory1<KtCallableDeclaration, K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>
            TYPE_PARAMETER_NAMES_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, TYPE_PARAMETERS_OR_DECLARATION_SIGNATURE);

    DiagnosticFactory3<KtClassLikeDeclaration, ClassifierDescriptorWithTypeParameters, List<Name>, ClassDescriptor>
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.diagnostics.UnboundDiagnostic;
 import org.jetbrains.kotlin.metadata.deserialization.VersionRequirement;
 import org.jetbrains.kotlin.resolve.VarianceConflictDiagnosticData;
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.Incompatible;
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility.Incompatible;
 import org.jetbrains.kotlin.types.KotlinTypeKt;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.kotlin.utils.addToStdlib.AddToStdlibKt;
@@ -20,8 +20,8 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.MemberDescriptor
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.Incompatible
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMemberDiff
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility.Incompatible
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualMemberDiff
 import java.text.MessageFormat

 class PlatformIncompatibilityDiagnosticRenderer(
@@ -68,9 +68,9 @@ class IncompatibleExpectedActualClassScopesRenderer(

 class ExpectActualScopeDiffsRenderer(
    private val mode: MultiplatformDiagnosticRenderingMode,
-) : DiagnosticParameterRenderer<Set<ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>> {
+) : DiagnosticParameterRenderer<Set<K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>> {
    override fun render(
-        obj: Set<ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>,
+        obj: Set<K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>>,
        renderingContext: RenderingContext,
    ): String {
        check(obj.isNotEmpty())
@@ -90,9 +90,9 @@ class ExpectActualScopeDiffsRenderer(
    }
 }

-object ExpectActualScopeDiffRenderer : DiagnosticParameterRenderer<ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>> {
+object ExpectActualScopeDiffRenderer : DiagnosticParameterRenderer<K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>> {
    override fun render(
-        obj: ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>,
+        obj: K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>,
        renderingContext: RenderingContext,
    ): String = MessageFormat.format(
        obj.kind.rawMessage,
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualCompatibilityChecker
+import org.jetbrains.kotlin.resolve.multiplatform.K1AbstractExpectActualCompatibilityChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
@@ -124,7 +124,7 @@ internal fun matchActualWithNonFinalExpect(
    if (actual.modality == Modality.FINAL) return null

    val expect = ExpectedActualResolver.findExpectedForActual(descriptor)
-        ?.get(ExpectActualCompatibility.Compatible)
+        ?.get(K1ExpectActualCompatibility.Compatible)
        ?.singleOrNull() as? ClassDescriptor // if actual has more than one expects then it will be reported by another checker
        ?: return null

@@ -135,7 +135,7 @@ internal fun matchActualWithNonFinalExpect(
 private fun calculateExpectActualScopeDiff(
    expect: ClassDescriptor,
    actual: ClassDescriptor,
-): Set<ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>> {
+): Set<K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>> {
    val matchingContext = ClassicExpectActualMatchingContext(actual.module)
    // It's responsibility of AbstractExpectActualCompatibilityChecker to report that. Most probably this check is redundant,
    // because we can't reach this line if expect and actual don't match, but let's have it for safety
@@ -155,11 +155,11 @@ private fun calculateExpectActualScopeDiff(
    return actualClassCallables.flatMap { actualMember ->
        val potentialExpects = nameAndKindToExpectCallables[actualMember.name to actualMember.functionVsPropertyKind]
        if (potentialExpects.isNullOrEmpty()) {
-            listOf(ExpectActualMemberDiff.Kind.NonPrivateCallableAdded)
+            listOf(K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded)
        } else {
            potentialExpects
                .map { expectMember ->
-                    AbstractExpectActualCompatibilityChecker.getCallablesCompatibility(
+                    K1AbstractExpectActualCompatibilityChecker.getCallablesCompatibility(
                        expectMember,
                        actualMember,
                        classTypeSubstitutor,
@@ -168,22 +168,22 @@ private fun calculateExpectActualScopeDiff(
                        matchingContext
                    )
                }
-                .takeIf { kinds -> kinds.all { it != ExpectActualCompatibility.Compatible } }
+                .takeIf { kinds -> kinds.all { it != K1ExpectActualCompatibility.Compatible } }
                .orEmpty()
                .map {
                    when (it) {
-                        is ExpectActualCompatibility.Compatible -> error("Compatible was filtered out by takeIf")
-                        is ExpectActualCompatibility.Incompatible -> it.toMemberDiffKind()
+                        is K1ExpectActualCompatibility.Compatible -> error("Compatible was filtered out by takeIf")
+                        is K1ExpectActualCompatibility.Incompatible -> it.toMemberDiffKind()
                        // If toMemberDiffKind returns null then some Kotlin invariants described in toMemberDiffKind no longer hold.
                        // We can't throw exception here because it would crash the compilation.
                        // Those broken invariants just needs to be reported by other checkers.
                        // But it's better to report some error (ExpectActualMemberDiff.Kind.NonPrivateCallableAdded in our case) to
                        // make sure that we don't have missed compilation errors if the invariants change
-                            ?: ExpectActualMemberDiff.Kind.NonPrivateCallableAdded
+                            ?: K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded
                    }
                }
        }
-            .map { kind -> ExpectActualMemberDiff(kind, actualMember, expect) }
+            .map { kind -> K1ExpectActualMemberDiff(kind, actualMember, expect) }
    }.toSet()
 }

@@ -206,26 +206,26 @@ private val CallableMemberDescriptor.functionVsPropertyKind: Kind
 private val CallableMemberDescriptor.psiIfReal: KtCallableDeclaration?
    get() = takeIf { it.kind.isReal }?.source?.let { it as? KotlinSourceElement }?.psi as? KtCallableDeclaration

-private fun BindingTrace.reportIfPossible(diff: ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>) {
+private fun BindingTrace.reportIfPossible(diff: K1ExpectActualMemberDiff<CallableMemberDescriptor, ClassDescriptor>) {
    val psi = diff.actualMember.psiIfReal ?: return
    val diagnostic = when (diff.kind) {
-        ExpectActualMemberDiff.Kind.NonPrivateCallableAdded ->
+        K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded ->
            Errors.NON_ACTUAL_MEMBER_DECLARED_IN_EXPECT_NON_FINAL_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.ReturnTypeChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.ReturnTypeChangedInOverride ->
            Errors.RETURN_TYPE_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.ModalityChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.ModalityChangedInOverride ->
            Errors.MODALITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.VisibilityChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.VisibilityChangedInOverride ->
            Errors.VISIBILITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.SetterVisibilityChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.SetterVisibilityChangedInOverride ->
            Errors.SETTER_VISIBILITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on((psi as? KtProperty)?.setter ?: return, diff)
-        ExpectActualMemberDiff.Kind.ParameterNameChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.ParameterNameChangedInOverride ->
            Errors.PARAMETER_NAME_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.PropertyKindChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.PropertyKindChangedInOverride ->
            Errors.PROPERTY_KIND_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.LateinitChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.LateinitChangedInOverride ->
            Errors.LATEINIT_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
-        ExpectActualMemberDiff.Kind.TypeParameterNamesChangedInOverride ->
+        K1ExpectActualMemberDiff.Kind.TypeParameterNamesChangedInOverride ->
            Errors.TYPE_PARAMETER_NAMES_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING.on(psi, diff)
    }
    report(diagnostic)
@@ -29,13 +29,13 @@ import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.hasActualModifier
 import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualAnnotationMatchChecker
+import org.jetbrains.kotlin.resolve.multiplatform.K1AbstractExpectActualAnnotationMatchChecker
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.isAnnotationConstructor
 import org.jetbrains.kotlin.resolve.descriptorUtil.isPrimaryConstructorOfInlineClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.multiplatform.*
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.*
+import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility.*
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
 import org.jetbrains.kotlin.resolve.source.PsiSourceFile
@@ -286,7 +286,7 @@ class ExpectedActualDeclarationChecker(
    }

    private fun MemberDescriptor.hasNoActualWithDiagnostic(
-        compatibility: Map<ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>
+        compatibility: Map<K1ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>
    ): Boolean {
        return compatibility.values.flatMapTo(hashSetOf()) { it }.all { actual ->
            val expectedOnes = ExpectedActualResolver.findExpectedForActual(actual, onlyFromThisModule(module))
@@ -406,7 +406,7 @@ class ExpectedActualDeclarationChecker(
    }

    private fun checkAmbiguousExpects(
-        compatibility: Map<ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>,
+        compatibility: Map<K1ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>,
        trace: BindingTrace,
        reportOn: KtNamedDeclaration,
        descriptor: MemberDescriptor
@@ -514,7 +514,7 @@ class ExpectedActualDeclarationChecker(
        if (!context.languageVersionSettings.supportsFeature(LanguageFeature.MultiplatformRestrictions)) return
        val matchingContext = ClassicExpectActualMatchingContext(actualDescriptor.module)
        val incompatibility =
-            AbstractExpectActualAnnotationMatchChecker.areAnnotationsCompatible(expectDescriptor, actualDescriptor, matchingContext) ?: return
+            K1AbstractExpectActualAnnotationMatchChecker.areAnnotationsCompatible(expectDescriptor, actualDescriptor, matchingContext) ?: return
        val actualAnnotationTargetSourceElement = (incompatibility.actualAnnotationTargetElement as ClassicSourceElement).element
        context.trace.report(
            Errors.ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT.on(
@@ -528,9 +528,9 @@ class ExpectedActualDeclarationChecker(
    }

    companion object {
-        fun Map<out ExpectActualCompatibility<MemberDescriptor>, Collection<MemberDescriptor>>.allStrongIncompatibilities(): Boolean =
+        fun Map<out K1ExpectActualCompatibility<MemberDescriptor>, Collection<MemberDescriptor>>.allStrongIncompatibilities(): Boolean =
            this.keys.all { it is Incompatible.StrongIncompatible }
    }
 }

-private typealias ActualsMap = Map<ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>
+private typealias ActualsMap = Map<K1ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>