diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10MultiplatformInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10MultiplatformInfoProvider.kt index bbb43c1b8d8..6a5643852a8 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10MultiplatformInfoProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10MultiplatformInfoProvider.kt @@ -15,8 +15,8 @@ import org.jetbrains.kotlin.analysis.api.symbols.psiSafe import org.jetbrains.kotlin.descriptors.MemberDescriptor import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.psiUtil.hasActualModifier -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver +import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility internal class KtFe10MultiplatformInfoProvider( override val analysisSession: KtFe10AnalysisSession, @@ -28,7 +28,7 @@ internal class KtFe10MultiplatformInfoProvider( val expectedCompatibilityMap = ExpectedActualResolver.findExpectedForActual(memberDescriptor) ?: return emptyList() - val expectsForActual = (expectedCompatibilityMap[ExpectActualCompatibility.Compatible] + val expectsForActual = (expectedCompatibilityMap[K1ExpectActualCompatibility.Compatible] ?: expectedCompatibilityMap.values.flatten()) return expectsForActual.map { it.toKtSymbol(analysisContext) as KtDeclarationSymbol } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/ClassicPositioningStrategies.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/ClassicPositioningStrategies.kt index c7645b94212..047766dbac6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/ClassicPositioningStrategies.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/ClassicPositioningStrategies.kt @@ -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? + private val DiagnosticMarker.firstIncompatibility: K1ExpectActualCompatibility.Incompatible? 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, Collection> ?: return null + } as? Map, Collection> ?: 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) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 12713e7cb7d..acf6e07eb61 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -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 EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE = DiagnosticFactory1.create(WARNING, DECLARATION_NAME); - DiagnosticFactory3>, ClassDescriptor> + DiagnosticFactory3>, ClassDescriptor> ACTUAL_CLASSIFIER_MUST_HAVE_THE_SAME_MEMBERS_AS_NON_FINAL_EXPECT_CLASSIFIER_WARNING = DiagnosticFactory3.create(WARNING, DECLARATION_NAME); - DiagnosticFactory1> + DiagnosticFactory1> NON_ACTUAL_MEMBER_DECLARED_IN_EXPECT_NON_FINAL_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, DECLARATION_NAME); - DiagnosticFactory1> + DiagnosticFactory1> RETURN_TYPE_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, DECLARATION_RETURN_TYPE); - DiagnosticFactory1> + DiagnosticFactory1> MODALITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, MODALITY_MODIFIER); - DiagnosticFactory1> + DiagnosticFactory1> VISIBILITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, VISIBILITY_MODIFIER); - DiagnosticFactory1> + DiagnosticFactory1> SETTER_VISIBILITY_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, VISIBILITY_MODIFIER); - DiagnosticFactory1> + DiagnosticFactory1> PARAMETER_NAME_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, DECLARATION_NAME); - DiagnosticFactory1> + DiagnosticFactory1> PROPERTY_KIND_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, VAL_OR_VAR_NODE); - DiagnosticFactory1> + DiagnosticFactory1> LATEINIT_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, LATEINIT_MODIFIER); - DiagnosticFactory1> + DiagnosticFactory1> TYPE_PARAMETER_NAMES_CHANGED_IN_NON_FINAL_EXPECT_CLASSIFIER_ACTUALIZATION_WARNING = DiagnosticFactory1.create(WARNING, TYPE_PARAMETERS_OR_DECLARATION_SIGNATURE); DiagnosticFactory3, ClassDescriptor> diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index cda053a09b8..cc53afbd80d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -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; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt index f841b870468..007875bb06d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt @@ -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>> { +) : DiagnosticParameterRenderer>> { override fun render( - obj: Set>, + obj: Set>, renderingContext: RenderingContext, ): String { check(obj.isNotEmpty()) @@ -90,9 +90,9 @@ class ExpectActualScopeDiffsRenderer( } } -object ExpectActualScopeDiffRenderer : DiagnosticParameterRenderer> { +object ExpectActualScopeDiffRenderer : DiagnosticParameterRenderer> { override fun render( - obj: ExpectActualMemberDiff, + obj: K1ExpectActualMemberDiff, renderingContext: RenderingContext, ): String = MessageFormat.format( obj.kind.rawMessage, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ActualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ActualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker.kt index 7de60cc7cb5..801324cc73d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ActualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ActualClassifierMustHasTheSameMembersAsNonFinalExpectClassifierChecker.kt @@ -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> { +): Set> { 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) { +private fun BindingTrace.reportIfPossible(diff: K1ExpectActualMemberDiff) { 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) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt index dda08dcc28d..fa18bb3d38a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt @@ -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, List> + compatibility: Map, List> ): 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, List>, + compatibility: Map, List>, 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, Collection>.allStrongIncompatibilities(): Boolean = + fun Map, Collection>.allStrongIncompatibilities(): Boolean = this.keys.all { it is Incompatible.StrongIncompatible } } } -private typealias ActualsMap = Map, List> +private typealias ActualsMap = Map, List> diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt index 8cc73b033db..182cf9176de 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ClassicExpectActualMatchingContext.kt @@ -15,11 +15,9 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.calls.components.ClassicTypeSystemContextForCS -import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualCollectionArgumentsCompatibilityCheckStrategy -import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext -import org.jetbrains.kotlin.resolve.calls.mpp.ExpectActualMatchingContext.AnnotationCallInfo import org.jetbrains.kotlin.resolve.checkers.OptInNames import org.jetbrains.kotlin.resolve.descriptorUtil.* +import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualMatchingContext.AnnotationCallInfo import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered @@ -44,7 +42,7 @@ class ClassicExpectActualMatchingContext( * Otherwise, it won't be possible to suppress the compilation error in user code */ override val shouldCheckAbsenceOfDefaultParamsInActual: Boolean = false -) : ExpectActualMatchingContext, +) : K1ExpectActualMatchingContext, TypeSystemContext by ClassicTypeSystemContextForCS(platformModule.builtIns, KotlinTypeRefiner.Default) { override val shouldCheckReturnTypesOfCallables: Boolean get() = true @@ -363,7 +361,7 @@ class ClassicExpectActualMatchingContext( override fun areAnnotationArgumentsEqual( expectAnnotation: AnnotationCallInfo, actualAnnotation: AnnotationCallInfo, - collectionArgumentsCompatibilityCheckStrategy: ExpectActualCollectionArgumentsCompatibilityCheckStrategy, + collectionArgumentsCompatibilityCheckStrategy: K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy, ): Boolean { fun AnnotationCallInfo.getDescriptor(): AnnotationDescriptor = (this as AnnotationCallInfoImpl).annotationDescriptor @@ -428,7 +426,7 @@ class ClassicExpectActualMatchingContext( actualClass: RegularClassSymbolMarker, actualMember: DeclarationSymbolMarker, checkClassScopesCompatibility: Boolean, - ): Map> { + ): Map> { val compatibilityToExpects = ExpectedActualResolver.findExpectForActualClassMember( actualMember as MemberDescriptor, actualClass as ClassDescriptor, diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt index b50398523da..da864c9117b 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt @@ -6,10 +6,9 @@ package org.jetbrains.kotlin.resolve.multiplatform import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualCompatibilityChecker import org.jetbrains.kotlin.resolve.descriptorUtil.classId import org.jetbrains.kotlin.resolve.descriptorUtil.module -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.Compatible +import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility.Compatible import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.utils.addToStdlib.runIf @@ -18,7 +17,7 @@ object ExpectedActualResolver { expected: MemberDescriptor, platformModule: ModuleDescriptor, moduleVisibilityFilter: ModuleFilter = allModulesProvidingActualsFor(expected.module, platformModule), - ): Map, List>? { + ): Map, List>? { val context = ClassicExpectActualMatchingContext(platformModule) return when (expected) { is CallableMemberDescriptor -> { @@ -29,7 +28,7 @@ object ExpectedActualResolver { // TODO: support non-source definitions (e.g. from Java) actual.couldHaveASource }.groupBy { actual -> - AbstractExpectActualCompatibilityChecker.getCallablesCompatibility( + K1AbstractExpectActualCompatibilityChecker.getCallablesCompatibility( expected, actual, parentSubstitutor = null, @@ -43,7 +42,7 @@ object ExpectedActualResolver { context.findClassifiersFromModule(expected.classId, platformModule, moduleVisibilityFilter).filter { actual -> expected != actual && !actual.isExpect && actual.couldHaveASource }.groupBy { actual -> - AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility( + K1AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility( expected, actual, checkClassScopesCompatibility = true, @@ -61,7 +60,7 @@ object ExpectedActualResolver { expectClass: ClassDescriptor, checkClassScopesCompatibility: Boolean, context: ClassicExpectActualMatchingContext, - ): Map, List> { + ): Map, List> { val candidates = with(context) { expectClass.getMembersForExpectClass(actual.name) } @@ -90,7 +89,7 @@ object ExpectedActualResolver { actual: MemberDescriptor, moduleFilter: (ModuleDescriptor) -> Boolean = allModulesProvidingExpectsFor(actual.module), shouldCheckAbsenceOfDefaultParamsInActual: Boolean = false, - ): Map, List>? { + ): Map, List>? { val context = ClassicExpectActualMatchingContext(actual.module, shouldCheckAbsenceOfDefaultParamsInActual) return when (actual) { is CallableMemberDescriptor -> { @@ -124,7 +123,7 @@ object ExpectedActualResolver { candidates: Collection, container: DeclarationDescriptor, context: ClassicExpectActualMatchingContext, - ): Map, List> { + ): Map, List> { return candidates.filter { declaration -> actual != declaration && declaration.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE && declaration.isExpect }.groupBy { declaration -> @@ -147,7 +146,7 @@ object ExpectedActualResolver { } else -> null } - AbstractExpectActualCompatibilityChecker.getCallablesCompatibility( + K1AbstractExpectActualCompatibilityChecker.getCallablesCompatibility( expectDeclaration = declaration, actualDeclaration = actual, parentSubstitutor = substitutor, @@ -163,11 +162,11 @@ object ExpectedActualResolver { candidates: Collection, checkClassScopesCompatibility: Boolean, context: ClassicExpectActualMatchingContext, - ): Map, List> { + ): Map, List> { return candidates.filter { declaration -> actual != declaration && declaration is ClassDescriptor && declaration.isExpect }.groupBy { expected -> - AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility( + K1AbstractExpectActualCompatibilityChecker.getClassifiersCompatibility( expected as ClassDescriptor, actual, checkClassScopesCompatibility, diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualAnnotationMatchChecker.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualAnnotationMatchChecker.kt index 40f5c353fd5..bf359e0172f 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualAnnotationMatchChecker.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualAnnotationMatchChecker.kt @@ -3,7 +3,7 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.resolve.calls.mpp +package org.jetbrains.kotlin.resolve.multiplatform import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.mpp.* @@ -11,10 +11,9 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.resolve.checkers.OptInNames -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType as IncompatibilityType -object AbstractExpectActualAnnotationMatchChecker { +object K1AbstractExpectActualAnnotationMatchChecker { private val SKIPPED_CLASS_IDS = setOf( StandardClassIds.Annotations.Deprecated, StandardClassIds.Annotations.DeprecatedSinceKotlin, @@ -45,19 +44,18 @@ object AbstractExpectActualAnnotationMatchChecker { * Needed for the implementation of IDE intention. */ val actualAnnotationTargetElement: SourceElementMarker, - val type: IncompatibilityType, + val type: IncompatibilityType, ) fun areAnnotationsCompatible( expectSymbol: DeclarationSymbolMarker, actualSymbol: DeclarationSymbolMarker, - context: ExpectActualMatchingContext<*>, + context: K1ExpectActualMatchingContext<*>, ): Incompatibility? = with(context) { areAnnotationsCompatible(expectSymbol, actualSymbol) } - context (ExpectActualMatchingContext<*>) - private fun areAnnotationsCompatible( + private fun K1ExpectActualMatchingContext<*>.areAnnotationsCompatible( expectSymbol: DeclarationSymbolMarker, actualSymbol: DeclarationSymbolMarker, ): Incompatibility? { @@ -72,8 +70,7 @@ object AbstractExpectActualAnnotationMatchChecker { } } - context (ExpectActualMatchingContext<*>) - private fun areCallableAnnotationsCompatible( + private fun K1ExpectActualMatchingContext<*>.areCallableAnnotationsCompatible( expectSymbol: CallableSymbolMarker, actualSymbol: CallableSymbolMarker, ): Incompatibility? { @@ -87,8 +84,7 @@ object AbstractExpectActualAnnotationMatchChecker { return null } - context (ExpectActualMatchingContext<*>) - private fun arePropertyGetterAndSetterAnnotationsCompatible( + private fun K1ExpectActualMatchingContext<*>.arePropertyGetterAndSetterAnnotationsCompatible( expectSymbol: PropertySymbolMarker, actualSymbol: PropertySymbolMarker, ): Incompatibility? { @@ -106,8 +102,7 @@ object AbstractExpectActualAnnotationMatchChecker { return null } - context (ExpectActualMatchingContext<*>) - private fun areClassAnnotationsCompatible( + private fun K1ExpectActualMatchingContext<*>.areClassAnnotationsCompatible( expectSymbol: RegularClassSymbolMarker, actualSymbol: ClassLikeSymbolMarker, ): Incompatibility? { @@ -129,8 +124,7 @@ object AbstractExpectActualAnnotationMatchChecker { return null } - context (ExpectActualMatchingContext<*>) - private fun commonForClassAndCallableChecks( + private fun K1ExpectActualMatchingContext<*>.commonForClassAndCallableChecks( expectSymbol: DeclarationSymbolMarker, actualSymbol: DeclarationSymbolMarker, ): Incompatibility? { @@ -140,8 +134,7 @@ object AbstractExpectActualAnnotationMatchChecker { return null } - context (ExpectActualMatchingContext<*>) - private fun areAnnotationsOnValueParametersCompatible( + private fun K1ExpectActualMatchingContext<*>.areAnnotationsOnValueParametersCompatible( expectSymbol: CallableSymbolMarker, actualSymbol: CallableSymbolMarker, ): Incompatibility? { @@ -158,8 +151,7 @@ object AbstractExpectActualAnnotationMatchChecker { } } - context (ExpectActualMatchingContext<*>) - private fun areAnnotationsOnTypeParametersCompatible( + private fun K1ExpectActualMatchingContext<*>.areAnnotationsOnTypeParametersCompatible( expectSymbol: DeclarationSymbolMarker, actualSymbol: DeclarationSymbolMarker, ): Incompatibility? { @@ -183,8 +175,7 @@ object AbstractExpectActualAnnotationMatchChecker { } } - context (ExpectActualMatchingContext<*>) - private fun areAnnotationsSetOnDeclarationsCompatible( + private fun K1ExpectActualMatchingContext<*>.areAnnotationsSetOnDeclarationsCompatible( expectSymbol: DeclarationSymbolMarker, actualSymbol: DeclarationSymbolMarker, ): Incompatibility? { @@ -227,16 +218,15 @@ object AbstractExpectActualAnnotationMatchChecker { } private fun getAnnotationCollectionArgumentsCompatibilityChecker(annotationClassId: ClassId): - ExpectActualCollectionArgumentsCompatibilityCheckStrategy { + K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy { return if (annotationClassId == StandardClassIds.Annotations.Target) { - ExpectActualCollectionArgumentsCompatibilityCheckStrategy.ExpectIsSubsetOfActual + K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.ExpectIsSubsetOfActual } else { - ExpectActualCollectionArgumentsCompatibilityCheckStrategy.Default + K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.Default } } - context (ExpectActualMatchingContext<*>) - private fun checkAnnotationsInClassMemberScope( + private fun K1ExpectActualMatchingContext<*>.checkAnnotationsInClassMemberScope( expectClass: RegularClassSymbolMarker, actualClass: RegularClassSymbolMarker, ): Incompatibility? { @@ -252,7 +242,7 @@ object AbstractExpectActualAnnotationMatchChecker { // so we are sure that we found the right member. checkClassScopesCompatibility = false, ) - val expectMember = expectToCompatibilityMap.filter { it.value == ExpectActualCompatibility.Compatible }.keys.singleOrNull() + val expectMember = expectToCompatibilityMap.filter { it.value == K1ExpectActualCompatibility.Compatible }.keys.singleOrNull() // Check also incompatible members if only one is found ?: expectToCompatibilityMap.keys.singleOrNull() ?: continue @@ -261,8 +251,7 @@ object AbstractExpectActualAnnotationMatchChecker { return null } - context (ExpectActualMatchingContext<*>) - private fun checkAnnotationsOnEnumEntries( + private fun K1ExpectActualMatchingContext<*>.checkAnnotationsOnEnumEntries( expectClassSymbol: RegularClassSymbolMarker, actualClassSymbol: RegularClassSymbolMarker, ): Incompatibility? { diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualCompatibilityChecker.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualCompatibilityChecker.kt index 1a27593c876..c335e933164 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualCompatibilityChecker.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualCompatibilityChecker.kt @@ -3,7 +3,9 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.resolve.calls.mpp +@file:Suppress("DuplicatedCode") // Yes, it's duplicated. But it doesn't matter, K1 version will just die eventually + +package org.jetbrains.kotlin.resolve.multiplatform import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality @@ -12,8 +14,7 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.mpp.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.SpecialNames -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility.Incompatible +import org.jetbrains.kotlin.resolve.multiplatform.K1ExpectActualCompatibility.Incompatible import org.jetbrains.kotlin.types.model.KotlinTypeMarker import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker import org.jetbrains.kotlin.utils.SmartList @@ -22,18 +23,18 @@ import org.jetbrains.kotlin.utils.addToStdlib.enumSetOf import org.jetbrains.kotlin.utils.keysToMap import java.util.* -object AbstractExpectActualCompatibilityChecker { +object K1AbstractExpectActualCompatibilityChecker { fun getClassifiersCompatibility( expectClassSymbol: RegularClassSymbolMarker, actualClassLikeSymbol: ClassLikeSymbolMarker, checkClassScopesCompatibility: Boolean, - context: ExpectActualMatchingContext, - ): ExpectActualCompatibility { + context: K1ExpectActualMatchingContext, + ): K1ExpectActualCompatibility { val result = with(context) { getClassifiersCompatibility(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor = null, checkClassScopesCompatibility) } @Suppress("UNCHECKED_CAST") - return result as ExpectActualCompatibility + return result as K1ExpectActualCompatibility } fun getCallablesCompatibility( @@ -42,53 +43,33 @@ object AbstractExpectActualCompatibilityChecker { parentSubstitutor: TypeSubstitutorMarker?, expectContainingClass: RegularClassSymbolMarker?, actualContainingClass: RegularClassSymbolMarker?, - context: ExpectActualMatchingContext, - ): ExpectActualCompatibility { + context: K1ExpectActualMatchingContext, + ): K1ExpectActualCompatibility { val result = with(context) { getCallablesCompatibility(expectDeclaration, actualDeclaration, parentSubstitutor, expectContainingClass, actualContainingClass) } @Suppress("UNCHECKED_CAST") - return result as ExpectActualCompatibility + return result as K1ExpectActualCompatibility } - fun matchSingleExpectTopLevelDeclarationAgainstPotentialActuals( - expectDeclaration: DeclarationSymbolMarker, - actualDeclarations: List, - context: ExpectActualMatchingContext, - ) { - with(context) { - matchSingleExpectAgainstPotentialActuals( - expectDeclaration, - actualDeclarations, - substitutor = null, - expectClassSymbol = null, - actualClassSymbol = null, - unfulfilled = null, - checkClassScopesCompatibility = true, - ) - } - } - - context(ExpectActualMatchingContext<*>) @Suppress("warnings") - private fun getClassifiersCompatibility( + private fun K1ExpectActualMatchingContext<*>.getClassifiersCompatibility( expectClassSymbol: RegularClassSymbolMarker, actualClassLikeSymbol: ClassLikeSymbolMarker, parentSubstitutor: TypeSubstitutorMarker?, checkClassScopes: Boolean, - ): ExpectActualCompatibility<*> = getClassifiersIncompatibility(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor, checkClassScopes) - ?: ExpectActualCompatibility.Compatible + ): K1ExpectActualCompatibility<*> = getClassifiersIncompatibility(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor, checkClassScopes) + ?: K1ExpectActualCompatibility.Compatible - context(ExpectActualMatchingContext<*>) @Suppress("warnings") - private fun getClassifiersIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getClassifiersIncompatibility( expectClassSymbol: RegularClassSymbolMarker, actualClassLikeSymbol: ClassLikeSymbolMarker, parentSubstitutor: TypeSubstitutorMarker?, checkClassScopesCompatibility: Boolean, - ): ExpectActualCompatibility.Incompatible.WeakIncompatible<*>? { + ): K1ExpectActualCompatibility.Incompatible.WeakIncompatible<*>? { // Can't check FQ names here because nested expected class may be implemented via actual typealias's expansion with the other FQ name - require(expectClassSymbol.name == actualClassLikeSymbol.name) { + require(expectClassSymbol.getName(this) == actualClassLikeSymbol.getName(this)) { "This function should be invoked only for declarations with the same name: $expectClassSymbol, $actualClassLikeSymbol" } @@ -147,8 +128,7 @@ object AbstractExpectActualCompatibilityChecker { return null } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleSupertypes( + private fun K1ExpectActualMatchingContext<*>.areCompatibleSupertypes( expectClassSymbol: RegularClassSymbolMarker, actualClassSymbol: RegularClassSymbolMarker, substitutor: TypeSubstitutorMarker, @@ -159,8 +139,7 @@ object AbstractExpectActualCompatibilityChecker { } } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleSupertypesOneByOne( + private fun K1ExpectActualMatchingContext<*>.areCompatibleSupertypesOneByOne( expectClassSymbol: RegularClassSymbolMarker, actualClassSymbol: RegularClassSymbolMarker, substitutor: TypeSubstitutorMarker, @@ -177,8 +156,7 @@ object AbstractExpectActualCompatibilityChecker { } } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleSupertypesTransitive( + private fun K1ExpectActualMatchingContext<*>.areCompatibleSupertypesTransitive( expectClassSymbol: RegularClassSymbolMarker, actualClassSymbol: RegularClassSymbolMarker, substitutor: TypeSubstitutorMarker, @@ -193,20 +171,19 @@ object AbstractExpectActualCompatibilityChecker { } } - context(ExpectActualMatchingContext<*>) - private fun getClassScopesIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getClassScopesIncompatibility( expectClassSymbol: RegularClassSymbolMarker, actualClassSymbol: RegularClassSymbolMarker, substitutor: TypeSubstitutorMarker, ): Incompatible.WeakIncompatible<*>? { val unfulfilled = arrayListOf, List>>>() - val actualMembersByName = actualClassSymbol.collectAllMembers(isActualDeclaration = true).groupBy { it.name } + val actualMembersByName = actualClassSymbol.collectAllMembers(isActualDeclaration = true).groupBy { it.getName(this) } outer@ for (expectMember in expectClassSymbol.collectAllMembers(isActualDeclaration = false)) { if (expectMember is CallableSymbolMarker && expectMember.shouldSkipMatching(expectClassSymbol)) continue - val actualMembers = actualMembersByName[expectMember.name]?.filter { actualMember -> + val actualMembers = actualMembersByName[expectMember.getName(this)]?.filter { actualMember -> expectMember is CallableSymbolMarker && actualMember is CallableSymbolMarker || expectMember is RegularClassSymbolMarker && actualMember is RegularClassSymbolMarker }.orEmpty() @@ -236,8 +213,7 @@ object AbstractExpectActualCompatibilityChecker { return Incompatible.ClassScopes(unfulfilled) } - context(ExpectActualMatchingContext<*>) - private fun matchSingleExpectAgainstPotentialActuals( + private fun K1ExpectActualMatchingContext<*>.matchSingleExpectAgainstPotentialActuals( expectMember: DeclarationSymbolMarker, actualMembers: List, substitutor: TypeSubstitutorMarker?, @@ -272,7 +248,7 @@ object AbstractExpectActualCompatibilityChecker { val incompatibilityMap = mutableMapOf, MutableList>() for ((actualMember, compatibility) in mapping) { when (compatibility) { - ExpectActualCompatibility.Compatible -> { + K1ExpectActualCompatibility.Compatible -> { onMatchedMembers(expectMember, actualMember, expectClassSymbol, actualClassSymbol) return } @@ -285,14 +261,13 @@ object AbstractExpectActualCompatibilityChecker { onMismatchedMembersFromClassScope(expectMember, incompatibilityMap, expectClassSymbol, actualClassSymbol) } - context(ExpectActualMatchingContext<*>) - private fun getCallablesCompatibility( + private fun K1ExpectActualMatchingContext<*>.getCallablesCompatibility( expectDeclaration: CallableSymbolMarker, actualDeclaration: CallableSymbolMarker, parentSubstitutor: TypeSubstitutorMarker?, expectContainingClass: RegularClassSymbolMarker?, actualContainingClass: RegularClassSymbolMarker?, - ): ExpectActualCompatibility<*> { + ): K1ExpectActualCompatibility<*> { require( (expectDeclaration is ConstructorSymbolMarker && actualDeclaration is ConstructorSymbolMarker) || expectDeclaration.callableId.callableName == actualDeclaration.callableId.callableName @@ -310,17 +285,16 @@ object AbstractExpectActualCompatibilityChecker { expectDeclaration is ConstructorSymbolMarker && actualDeclaration is ConstructorSymbolMarker ) { - return ExpectActualCompatibility.Compatible + return K1ExpectActualCompatibility.Compatible } // We must prioritize to return STRONG incompatible over WEAK incompatible (because STRONG incompatibility allows to search for overloads) return getCallablesStrongIncompatibility(expectDeclaration, actualDeclaration, parentSubstitutor) ?: getCallablesWeakIncompatibility(expectDeclaration, actualDeclaration, expectContainingClass, actualContainingClass) - ?: ExpectActualCompatibility.Compatible + ?: K1ExpectActualCompatibility.Compatible } - context(ExpectActualMatchingContext<*>) - private fun getCallablesStrongIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getCallablesStrongIncompatibility( expectDeclaration: CallableSymbolMarker, actualDeclaration: CallableSymbolMarker, parentSubstitutor: TypeSubstitutorMarker?, @@ -355,8 +329,8 @@ object AbstractExpectActualCompatibilityChecker { if ( !areCompatibleTypeLists( - expectedValueParameters.toTypeList(substitutor), - actualValueParameters.toTypeList(createEmptySubstitutor()) + expectedValueParameters.toTypeList(substitutor, this), + actualValueParameters.toTypeList(createEmptySubstitutor(), this) ) || !areCompatibleExpectActualTypes( expectedReceiverType?.let { substitutor.safeSubstitute(it) }, @@ -379,8 +353,7 @@ object AbstractExpectActualCompatibilityChecker { return null } - context(ExpectActualMatchingContext<*>) - private fun getCallablesWeakIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getCallablesWeakIncompatibility( expectDeclaration: CallableSymbolMarker, actualDeclaration: CallableSymbolMarker, expectContainingClass: RegularClassSymbolMarker?, @@ -391,11 +364,11 @@ object AbstractExpectActualCompatibilityChecker { val expectedValueParameters = expectDeclaration.valueParameters val actualValueParameters = actualDeclaration.valueParameters - if (actualDeclaration.hasStableParameterNames && !equalsBy(expectedValueParameters, actualValueParameters) { it.name }) { + if (actualDeclaration.hasStableParameterNames && !equalsBy(expectedValueParameters, actualValueParameters) { it.getName(this) }) { return Incompatible.ParameterNames } - if (!equalsBy(expectedTypeParameters, actualTypeParameters) { it.name }) { + if (!equalsBy(expectedTypeParameters, actualTypeParameters) { it.getName(this) }) { return Incompatible.TypeParameterNames } @@ -465,8 +438,7 @@ object AbstractExpectActualCompatibilityChecker { return null } - context(ExpectActualMatchingContext<*>) - private fun valueParametersCountCompatible( + private fun K1ExpectActualMatchingContext<*>.valueParametersCountCompatible( expectDeclaration: CallableSymbolMarker, actualDeclaration: CallableSymbolMarker, expectValueParameters: List, @@ -481,8 +453,7 @@ object AbstractExpectActualCompatibilityChecker { } } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleTypeLists( + private fun K1ExpectActualMatchingContext<*>.areCompatibleTypeLists( expectedTypes: List, actualTypes: List, ): Boolean { @@ -494,14 +465,13 @@ object AbstractExpectActualCompatibilityChecker { return true } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleClassKinds( + private fun K1ExpectActualMatchingContext<*>.areCompatibleClassKinds( expectClass: RegularClassSymbolMarker, actualClass: RegularClassSymbolMarker, ): Boolean { if (expectClass.classKind == actualClass.classKind) return true - if (expectClass.classKind == ClassKind.CLASS && expectClass.isFinal && expectClass.isCtorless) { + if (expectClass.classKind == ClassKind.CLASS && expectClass.isFinal(this@areCompatibleClassKinds) && expectClass.isCtorless(this@areCompatibleClassKinds)) { if (actualClass.classKind == ClassKind.OBJECT) return true } @@ -555,8 +525,7 @@ object AbstractExpectActualCompatibilityChecker { } } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleClassVisibilities( + private fun K1ExpectActualMatchingContext<*>.areCompatibleClassVisibilities( expectClassSymbol: RegularClassSymbolMarker, actualClassSymbol: RegularClassSymbolMarker, ): Boolean { @@ -568,8 +537,7 @@ object AbstractExpectActualCompatibilityChecker { return result != null && result > 0 } - context(ExpectActualMatchingContext<*>) - private fun areCompatibleTypeParameterUpperBounds( + private fun K1ExpectActualMatchingContext<*>.areCompatibleTypeParameterUpperBounds( expectTypeParameterSymbols: List, actualTypeParameterSymbols: List, substitutor: TypeSubstitutorMarker, @@ -588,8 +556,7 @@ object AbstractExpectActualCompatibilityChecker { return true } - context(ExpectActualMatchingContext<*>) - private fun getTypeParametersVarianceOrReifiedIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getTypeParametersVarianceOrReifiedIncompatibility( expectTypeParameterSymbols: List, actualTypeParameterSymbols: List, ): Incompatible.WeakIncompatible<*>? { @@ -609,8 +576,7 @@ object AbstractExpectActualCompatibilityChecker { return null } - context(ExpectActualMatchingContext<*>) - private fun getFunctionsIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getFunctionsIncompatibility( expectFunction: CallableSymbolMarker, actualFunction: CallableSymbolMarker, ): Incompatible.WeakIncompatible<*>? { @@ -629,8 +595,7 @@ object AbstractExpectActualCompatibilityChecker { return null } - context(ExpectActualMatchingContext<*>) - private fun getPropertiesIncompatibility( + private fun K1ExpectActualMatchingContext<*>.getPropertiesIncompatibility( expected: PropertySymbolMarker, actual: PropertySymbolMarker, ): Incompatible.WeakIncompatible<*>? { @@ -643,8 +608,7 @@ object AbstractExpectActualCompatibilityChecker { } } - context(ExpectActualMatchingContext<*>) - private fun arePropertySettersWithCompatibleVisibilities( + private fun K1ExpectActualMatchingContext<*>.arePropertySettersWithCompatibleVisibilities( expected: PropertySymbolMarker, actual: PropertySymbolMarker, ): Boolean { @@ -655,9 +619,11 @@ object AbstractExpectActualCompatibilityChecker { // ---------------------------------------- Utils ---------------------------------------- - context(ExpectActualMatchingContext<*>) - private fun List.toTypeList(substitutor: TypeSubstitutorMarker): List { - return this.map { substitutor.safeSubstitute(it.returnType) } + private fun List.toTypeList( + substitutor: TypeSubstitutorMarker, + context: K1ExpectActualMatchingContext<*>, + ): List = with(context) { + return map { substitutor.safeSubstitute(it.returnType) } } private inline fun equalsBy(first: List, second: List, selector: (T) -> K): Boolean { @@ -671,9 +637,8 @@ object AbstractExpectActualCompatibilityChecker { private inline fun equalBy(first: T, second: T, selector: (T) -> K): Boolean = selector(first) == selector(second) - context(ExpectActualMatchingContext<*>) - private val DeclarationSymbolMarker.name: Name - get() = when (this) { + private fun DeclarationSymbolMarker.getName(context: K1ExpectActualMatchingContext<*>): Name = with(context) { + when (this@getName) { is ConstructorSymbolMarker -> SpecialNames.INIT is ValueParameterSymbolMarker -> parameterName is CallableSymbolMarker -> callableId.callableName @@ -682,12 +647,13 @@ object AbstractExpectActualCompatibilityChecker { is TypeParameterSymbolMarker -> parameterName else -> error("Unsupported declaration: $this") } + } - context(ExpectActualMatchingContext<*>) - private val RegularClassSymbolMarker.isCtorless: Boolean - get() = getMembersForExpectClass(SpecialNames.INIT).isEmpty() + private fun RegularClassSymbolMarker.isCtorless(context: K1ExpectActualMatchingContext<*>): Boolean = with(context) { + getMembersForExpectClass(SpecialNames.INIT).isEmpty() + } - context(ExpectActualMatchingContext<*>) - private val RegularClassSymbolMarker.isFinal: Boolean - get() = modality == Modality.FINAL + private fun RegularClassSymbolMarker.isFinal(context: K1ExpectActualMatchingContext<*>): Boolean = with(context) { + modality == Modality.FINAL + } } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.kt index 17228274e34..2beaebe6831 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.kt @@ -3,17 +3,17 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.resolve.calls.mpp +package org.jetbrains.kotlin.resolve.multiplatform -sealed class ExpectActualCollectionArgumentsCompatibilityCheckStrategy { +sealed class K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy { abstract fun areCompatible( expectArg: Collection, actualArg: Collection, elementsEqual: (T, T) -> Boolean, ): Boolean - data object Default : ExpectActualCollectionArgumentsCompatibilityCheckStrategy() { + data object Default : K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy() { override fun areCompatible( expectArg: Collection, actualArg: Collection, @@ -23,7 +23,7 @@ sealed class ExpectActualCollectionArgumentsCompatibilityCheckStrategy { } } - internal data object ExpectIsSubsetOfActual : ExpectActualCollectionArgumentsCompatibilityCheckStrategy() { + internal data object ExpectIsSubsetOfActual : K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy() { override fun areCompatible( expectArg: Collection, actualArg: Collection, diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCompatibility.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCompatibility.kt index b79e3163c62..33173ddae7b 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCompatibility.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCompatibility.kt @@ -8,10 +8,10 @@ package org.jetbrains.kotlin.resolve.multiplatform import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract -sealed class ExpectActualCompatibility { +sealed class K1ExpectActualCompatibility { // Note that the reason is used in the diagnostic output, see PlatformIncompatibilityDiagnosticRenderer - sealed class Incompatible(val reason: String?) : ExpectActualCompatibility() { + sealed class Incompatible(val reason: String?) : K1ExpectActualCompatibility() { sealed class WeakIncompatible(reason: String?) : Incompatible(reason) @@ -96,20 +96,20 @@ sealed class ExpectActualCompatibility { ) } - object Compatible : ExpectActualCompatibility() + object Compatible : K1ExpectActualCompatibility() } -val ExpectActualCompatibility<*>.isCompatibleOrWeaklyIncompatible: Boolean - get() = this is ExpectActualCompatibility.Compatible - || this is ExpectActualCompatibility.Incompatible.WeakIncompatible +val K1ExpectActualCompatibility<*>.isCompatibleOrWeaklyIncompatible: Boolean + get() = this is K1ExpectActualCompatibility.Compatible + || this is K1ExpectActualCompatibility.Incompatible.WeakIncompatible -val ExpectActualCompatibility<*>.compatible: Boolean - get() = this == ExpectActualCompatibility.Compatible +val K1ExpectActualCompatibility<*>.compatible: Boolean + get() = this == K1ExpectActualCompatibility.Compatible @OptIn(ExperimentalContracts::class) -fun ExpectActualCompatibility<*>.isIncompatible(): Boolean { +fun K1ExpectActualCompatibility<*>.isIncompatible(): Boolean { contract { - returns(true) implies (this@isIncompatible is ExpectActualCompatibility.Incompatible<*>) + returns(true) implies (this@isIncompatible is K1ExpectActualCompatibility.Incompatible<*>) } return !compatible } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMatchingContext.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMatchingContext.kt index 463a88b859f..b418be99972 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMatchingContext.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMatchingContext.kt @@ -3,7 +3,7 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.resolve.calls.mpp +package org.jetbrains.kotlin.resolve.multiplatform import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality @@ -12,13 +12,12 @@ import org.jetbrains.kotlin.mpp.* import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.model.KotlinTypeMarker import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker import org.jetbrains.kotlin.types.model.TypeSystemContext -interface ExpectActualMatchingContext : TypeSystemContext { +interface K1ExpectActualMatchingContext : TypeSystemContext { val shouldCheckReturnTypesOfCallables: Boolean /* @@ -170,7 +169,7 @@ interface ExpectActualMatchingContext : TypeSystemC fun onMismatchedMembersFromClassScope( expectSymbol: DeclarationSymbolMarker, - actualSymbolsByIncompatibility: Map, List>, + actualSymbolsByIncompatibility: Map, List>, containingExpectClassSymbol: RegularClassSymbolMarker?, containingActualClassSymbol: RegularClassSymbolMarker?, ) {} @@ -180,7 +179,7 @@ interface ExpectActualMatchingContext : TypeSystemC fun areAnnotationArgumentsEqual( expectAnnotation: AnnotationCallInfo, actualAnnotation: AnnotationCallInfo, - collectionArgumentsCompatibilityCheckStrategy: ExpectActualCollectionArgumentsCompatibilityCheckStrategy, + collectionArgumentsCompatibilityCheckStrategy: K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy, ): Boolean val DeclarationSymbolMarker.hasSourceAnnotationsErased: Boolean @@ -213,7 +212,7 @@ interface ExpectActualMatchingContext : TypeSystemC actualClass: RegularClassSymbolMarker, actualMember: DeclarationSymbolMarker, checkClassScopesCompatibility: Boolean, - ): Map> + ): Map> fun DeclarationSymbolMarker.getSourceElement(): SourceElementMarker } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMemberDiff.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMemberDiff.kt index c21cbd71c33..b4e0bd7442b 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMemberDiff.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMemberDiff.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.resolve.multiplatform // This class will be later used by K2. That's why it's placed in compiler.common module -data class ExpectActualMemberDiff(val kind: Kind, val actualMember: M, val expectClass: C) { +data class K1ExpectActualMemberDiff(val kind: Kind, val actualMember: M, val expectClass: C) { /** * Diff kinds that are legal for fake-overrides in final `expect class`, but illegal for non-final `expect class` * @@ -52,36 +52,36 @@ data class ExpectActualMemberDiff(val kind: Kind, val actualMember } } -fun ExpectActualCompatibility.Incompatible<*>.toMemberDiffKind(): ExpectActualMemberDiff.Kind? = when (this) { - ExpectActualCompatibility.Incompatible.CallableKind -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.ParameterCount -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.ParameterShape -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.ParameterTypes -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.ReturnType -> ExpectActualMemberDiff.Kind.ReturnTypeChangedInOverride - ExpectActualCompatibility.Incompatible.FunctionTypeParameterCount -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.ClassTypeParameterCount -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.FunctionTypeParameterUpperBounds -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.ClassTypeParameterUpperBounds -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.ActualFunctionWithDefaultParameters -> null // It's not possible to add default parameters in override - ExpectActualCompatibility.Incompatible.ClassKind -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.ClassModifiers -> error("Not applicable because ExpectActualMemberDiff is about members") - is ExpectActualCompatibility.Incompatible.ClassScopes -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.EnumEntries -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.FunInterfaceModifier -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.FunctionModifiersDifferent -> null // It's not possible to override with different function modifier (suspend) - ExpectActualCompatibility.Incompatible.FunctionModifiersNotSubset -> null // It's not possible to override with different function modifier (infix, inline, operator) - ExpectActualCompatibility.Incompatible.Modality -> ExpectActualMemberDiff.Kind.ModalityChangedInOverride - ExpectActualCompatibility.Incompatible.ParameterNames -> ExpectActualMemberDiff.Kind.ParameterNameChangedInOverride - ExpectActualCompatibility.Incompatible.PropertyConstModifier -> null // const fun can't be overridden - ExpectActualCompatibility.Incompatible.PropertyKind -> ExpectActualMemberDiff.Kind.PropertyKindChangedInOverride - ExpectActualCompatibility.Incompatible.PropertyLateinitModifier -> ExpectActualMemberDiff.Kind.LateinitChangedInOverride - ExpectActualCompatibility.Incompatible.PropertySetterVisibility -> ExpectActualMemberDiff.Kind.SetterVisibilityChangedInOverride - ExpectActualCompatibility.Incompatible.Supertypes -> error("Not applicable because ExpectActualMemberDiff is about members") - ExpectActualCompatibility.Incompatible.TypeParameterNames -> ExpectActualMemberDiff.Kind.TypeParameterNamesChangedInOverride - ExpectActualCompatibility.Incompatible.TypeParameterReified -> null // inline fun can't be overridden - ExpectActualCompatibility.Incompatible.TypeParameterVariance -> null // Members are not allowed to have variance - ExpectActualCompatibility.Incompatible.ValueParameterCrossinline -> null // inline fun can't be overridden - ExpectActualCompatibility.Incompatible.ValueParameterNoinline -> null // inline fun can't be overridden - ExpectActualCompatibility.Incompatible.ValueParameterVararg -> ExpectActualMemberDiff.Kind.NonPrivateCallableAdded - ExpectActualCompatibility.Incompatible.Visibility -> ExpectActualMemberDiff.Kind.VisibilityChangedInOverride +fun K1ExpectActualCompatibility.Incompatible<*>.toMemberDiffKind(): K1ExpectActualMemberDiff.Kind? = when (this) { + K1ExpectActualCompatibility.Incompatible.CallableKind -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.ParameterCount -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.ParameterShape -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.ParameterTypes -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.ReturnType -> K1ExpectActualMemberDiff.Kind.ReturnTypeChangedInOverride + K1ExpectActualCompatibility.Incompatible.FunctionTypeParameterCount -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.ClassTypeParameterCount -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.FunctionTypeParameterUpperBounds -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.ClassTypeParameterUpperBounds -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.ActualFunctionWithDefaultParameters -> null // It's not possible to add default parameters in override + K1ExpectActualCompatibility.Incompatible.ClassKind -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.ClassModifiers -> error("Not applicable because K1ExpectActualMemberDiff is about members") + is K1ExpectActualCompatibility.Incompatible.ClassScopes -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.EnumEntries -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.FunInterfaceModifier -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.FunctionModifiersDifferent -> null // It's not possible to override with different function modifier (suspend) + K1ExpectActualCompatibility.Incompatible.FunctionModifiersNotSubset -> null // It's not possible to override with different function modifier (infix, inline, operator) + K1ExpectActualCompatibility.Incompatible.Modality -> K1ExpectActualMemberDiff.Kind.ModalityChangedInOverride + K1ExpectActualCompatibility.Incompatible.ParameterNames -> K1ExpectActualMemberDiff.Kind.ParameterNameChangedInOverride + K1ExpectActualCompatibility.Incompatible.PropertyConstModifier -> null // const fun can't be overridden + K1ExpectActualCompatibility.Incompatible.PropertyKind -> K1ExpectActualMemberDiff.Kind.PropertyKindChangedInOverride + K1ExpectActualCompatibility.Incompatible.PropertyLateinitModifier -> K1ExpectActualMemberDiff.Kind.LateinitChangedInOverride + K1ExpectActualCompatibility.Incompatible.PropertySetterVisibility -> K1ExpectActualMemberDiff.Kind.SetterVisibilityChangedInOverride + K1ExpectActualCompatibility.Incompatible.Supertypes -> error("Not applicable because K1ExpectActualMemberDiff is about members") + K1ExpectActualCompatibility.Incompatible.TypeParameterNames -> K1ExpectActualMemberDiff.Kind.TypeParameterNamesChangedInOverride + K1ExpectActualCompatibility.Incompatible.TypeParameterReified -> null // inline fun can't be overridden + K1ExpectActualCompatibility.Incompatible.TypeParameterVariance -> null // Members are not allowed to have variance + K1ExpectActualCompatibility.Incompatible.ValueParameterCrossinline -> null // inline fun can't be overridden + K1ExpectActualCompatibility.Incompatible.ValueParameterNoinline -> null // inline fun can't be overridden + K1ExpectActualCompatibility.Incompatible.ValueParameterVararg -> K1ExpectActualMemberDiff.Kind.NonPrivateCallableAdded + K1ExpectActualCompatibility.Incompatible.Visibility -> K1ExpectActualMemberDiff.Kind.VisibilityChangedInOverride } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/constExpressionValuesEqualityChecker.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/constExpressionValuesEqualityChecker.kt index 5084e93a57a..c572990a22c 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/constExpressionValuesEqualityChecker.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/constExpressionValuesEqualityChecker.kt @@ -6,14 +6,13 @@ 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.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.KClassValue internal fun ClassicExpectActualMatchingContext.areExpressionConstValuesEqual( expectValue: Any?, actualValue: Any?, - collectionArgumentsCompatibilityCheckStrategy: ExpectActualCollectionArgumentsCompatibilityCheckStrategy, + collectionArgumentsCompatibilityCheckStrategy: K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy, ): Boolean { return when { expectValue is AnnotationDescriptor && actualValue is AnnotationDescriptor -> {