[FIR, IR] Cleanup. Drop no longer used ExpectActualCheckingCompatibility.Compatible
KT-62631
1. Drop no longer used ExpectActualCheckingCompatibility.Compatible
2. Merge ExpectActualCheckingCompatibility.Incompatible & ExpectActualCheckingCompatibility
3. Rename ExpectActualCheckingCompatibility to ExpectActualIncompatibility
diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt
index 0daaf93..ef4081e 100644
--- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt
+++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExpectActualDeclarationChecker.kt
@@ -25,7 +25,7 @@
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.mpp.RegularClassSymbolMarker
import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualChecker
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualIncompatibility
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
import org.jetbrains.kotlin.resolve.multiplatform.MemberIncompatibility
import org.jetbrains.kotlin.utils.addToStdlib.partitionIsInstance
@@ -186,12 +186,12 @@
}
val (classScopesIncompatibilities, normalIncompatibilities) =
- checkingIncompatibilities.partitionIsInstance<_, ExpectActualCheckingCompatibility.ClassScopes<FirBasedSymbol<*>>>()
+ checkingIncompatibilities.partitionIsInstance<_, ExpectActualIncompatibility.ClassScopes<FirBasedSymbol<*>>>()
for (incompatibility in normalIncompatibilities) {
check(expectedSingleCandidate != null) // It can't be null, because checkingIncompatibilities is not empty
// A nicer diagnostic for functions with default params
- if (declaration is FirFunction && incompatibility == ExpectActualCheckingCompatibility.ActualFunctionWithDefaultParameters) {
+ if (declaration is FirFunction && incompatibility == ExpectActualIncompatibility.ActualFunctionWithDefaultParameters) {
reporter.reportOn(declaration.source, FirErrors.ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS, context)
} else {
reporter.reportOn(
@@ -205,7 +205,7 @@
}
}
// CLASS_SCOPE incompatibilities might be confusing if class kinds or class modalities don't match
- if (normalIncompatibilities.none { it is ExpectActualCheckingCompatibility.ClassKind || it is ExpectActualCheckingCompatibility.Modality }) {
+ if (normalIncompatibilities.none { it is ExpectActualIncompatibility.ClassKind || it is ExpectActualIncompatibility.Modality }) {
for (incompatibility in classScopesIncompatibilities) {
reportClassScopesIncompatibility(symbol, expectedSingleCandidate, incompatibility, reporter, source, context)
}
@@ -215,7 +215,7 @@
private fun reportClassScopesIncompatibility(
symbol: FirBasedSymbol<FirDeclaration>,
expectedSingleCandidate: FirBasedSymbol<*>?,
- checkingCompatibility: ExpectActualCheckingCompatibility.ClassScopes<FirBasedSymbol<*>>,
+ checkingCompatibility: ExpectActualIncompatibility.ClassScopes<FirBasedSymbol<*>>,
reporter: DiagnosticReporter,
source: KtSourceElement?,
context: CheckerContext,
@@ -237,13 +237,13 @@
if (nonTrivialIncompatibleMembers.isNotEmpty()) {
val (defaultArgsIncompatibleMembers, otherIncompatibleMembers) =
- nonTrivialIncompatibleMembers.partition { it.incompatibility == ExpectActualCheckingCompatibility.DefaultParametersInExpectActualizedByFakeOverride }
+ nonTrivialIncompatibleMembers.partition { it.incompatibility == ExpectActualIncompatibility.DefaultParametersInExpectActualizedByFakeOverride }
if (defaultArgsIncompatibleMembers.isNotEmpty()) { // report a nicer diagnostic for DefaultArgumentsInExpectActualizedByFakeOverride
val problematicExpectMembers = defaultArgsIncompatibleMembers
.map {
it.expect as? FirNamedFunctionSymbol
- ?: error("${ExpectActualCheckingCompatibility.DefaultParametersInExpectActualizedByFakeOverride} can be reported only for ${FirNamedFunctionSymbol::class}")
+ ?: error("${ExpectActualIncompatibility.DefaultParametersInExpectActualizedByFakeOverride} can be reported only for ${FirNamedFunctionSymbol::class}")
}
reporter.reportOn(
source,
@@ -292,7 +292,7 @@
expectContainingClass: FirRegularClassSymbol?,
expectActualMatchingContext: FirExpectActualMatchingContext,
context: CheckerContext,
- ): List<ExpectActualCheckingCompatibility.Incompatible<FirBasedSymbol<*>>> =
+ ): List<ExpectActualIncompatibility<FirBasedSymbol<*>>> =
when {
actualSymbol is FirCallableSymbol<*> && expectSymbol is FirCallableSymbol<*> -> {
AbstractExpectActualChecker.getCallablesCompatibility(
@@ -379,35 +379,35 @@
actualContainingClass.primaryConstructorIfAny(platformSession)?.valueParameterSymbols?.singleOrNull() == symbol.correspondingValueParameterFromPrimaryConstructor
}
-private fun ExpectActualCheckingCompatibility.Incompatible<*>.toDiagnostic() = when (this) {
- ExpectActualCheckingCompatibility.ActualFunctionWithDefaultParameters -> error("unreachable")
- is ExpectActualCheckingCompatibility.ClassScopes<*> -> error("unreachable")
+private fun ExpectActualIncompatibility<*>.toDiagnostic() = when (this) {
+ ExpectActualIncompatibility.ActualFunctionWithDefaultParameters -> error("unreachable")
+ is ExpectActualIncompatibility.ClassScopes<*> -> error("unreachable")
- ExpectActualCheckingCompatibility.ClassKind -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_KIND
- ExpectActualCheckingCompatibility.ClassModifiers -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_MODIFIERS
- ExpectActualCheckingCompatibility.ClassTypeParameterCount -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_TYPE_PARAMETER_COUNT
- ExpectActualCheckingCompatibility.ClassTypeParameterUpperBounds -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_TYPE_PARAMETER_UPPER_BOUNDS
- ExpectActualCheckingCompatibility.ContextParameterNames -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CONTEXT_PARAMETER_NAMES
- ExpectActualCheckingCompatibility.DefaultParametersInExpectActualizedByFakeOverride -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_DEFAULT_PARAMETERS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE
- ExpectActualCheckingCompatibility.EnumEntries -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_ENUM_ENTRIES
- ExpectActualCheckingCompatibility.FunInterfaceModifier -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_FUN_INTERFACE_MODIFIER
- ExpectActualCheckingCompatibility.FunctionModifiersDifferent -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_FUNCTION_MODIFIERS_DIFFERENT
- ExpectActualCheckingCompatibility.FunctionModifiersNotSubset -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_FUNCTION_MODIFIERS_NOT_SUBSET
- ExpectActualCheckingCompatibility.IllegalRequiresOpt -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_ILLEGAL_REQUIRES_OPT_IN
- ExpectActualCheckingCompatibility.NestedTypeAlias -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_NESTED_TYPE_ALIAS
- ExpectActualCheckingCompatibility.ParameterNames -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PARAMETER_NAMES
- ExpectActualCheckingCompatibility.PropertyConstModifier -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_CONST_MODIFIER
- ExpectActualCheckingCompatibility.PropertyKind -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_KIND
- ExpectActualCheckingCompatibility.PropertyLateinitModifier -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_LATEINIT_MODIFIER
- ExpectActualCheckingCompatibility.ReturnType -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_RETURN_TYPE
- ExpectActualCheckingCompatibility.Supertypes -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_SUPERTYPES
- ExpectActualCheckingCompatibility.TypeParameterNames -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_TYPE_PARAMETER_NAMES
- ExpectActualCheckingCompatibility.TypeParameterReified -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_TYPE_PARAMETER_REIFIED
- ExpectActualCheckingCompatibility.TypeParameterVariance -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_TYPE_PARAMETER_VARIANCE
- ExpectActualCheckingCompatibility.ValueParameterCrossinline -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VALUE_PARAMETER_CROSSINLINE
- ExpectActualCheckingCompatibility.ValueParameterNoinline -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VALUE_PARAMETER_NOINLINE
- ExpectActualCheckingCompatibility.ValueParameterVararg -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VALUE_PARAMETER_VARARG
- is ExpectActualCheckingCompatibility.Modality -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_MODALITY
- is ExpectActualCheckingCompatibility.PropertySetterVisibility -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_SETTER_VISIBILITY
- is ExpectActualCheckingCompatibility.Visibility -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VISIBILITY
+ ExpectActualIncompatibility.ClassKind -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_KIND
+ ExpectActualIncompatibility.ClassModifiers -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_MODIFIERS
+ ExpectActualIncompatibility.ClassTypeParameterCount -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_TYPE_PARAMETER_COUNT
+ ExpectActualIncompatibility.ClassTypeParameterUpperBounds -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CLASS_TYPE_PARAMETER_UPPER_BOUNDS
+ ExpectActualIncompatibility.ContextParameterNames -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_CONTEXT_PARAMETER_NAMES
+ ExpectActualIncompatibility.DefaultParametersInExpectActualizedByFakeOverride -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_DEFAULT_PARAMETERS_IN_EXPECT_ACTUALIZED_BY_FAKE_OVERRIDE
+ ExpectActualIncompatibility.EnumEntries -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_ENUM_ENTRIES
+ ExpectActualIncompatibility.FunInterfaceModifier -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_FUN_INTERFACE_MODIFIER
+ ExpectActualIncompatibility.FunctionModifiersDifferent -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_FUNCTION_MODIFIERS_DIFFERENT
+ ExpectActualIncompatibility.FunctionModifiersNotSubset -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_FUNCTION_MODIFIERS_NOT_SUBSET
+ ExpectActualIncompatibility.IllegalRequiresOpt -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_ILLEGAL_REQUIRES_OPT_IN
+ ExpectActualIncompatibility.NestedTypeAlias -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_NESTED_TYPE_ALIAS
+ ExpectActualIncompatibility.ParameterNames -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PARAMETER_NAMES
+ ExpectActualIncompatibility.PropertyConstModifier -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_CONST_MODIFIER
+ ExpectActualIncompatibility.PropertyKind -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_KIND
+ ExpectActualIncompatibility.PropertyLateinitModifier -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_LATEINIT_MODIFIER
+ ExpectActualIncompatibility.ReturnType -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_RETURN_TYPE
+ ExpectActualIncompatibility.Supertypes -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_SUPERTYPES
+ ExpectActualIncompatibility.TypeParameterNames -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_TYPE_PARAMETER_NAMES
+ ExpectActualIncompatibility.TypeParameterReified -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_TYPE_PARAMETER_REIFIED
+ ExpectActualIncompatibility.TypeParameterVariance -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_TYPE_PARAMETER_VARIANCE
+ ExpectActualIncompatibility.ValueParameterCrossinline -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VALUE_PARAMETER_CROSSINLINE
+ ExpectActualIncompatibility.ValueParameterNoinline -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VALUE_PARAMETER_NOINLINE
+ ExpectActualIncompatibility.ValueParameterVararg -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VALUE_PARAMETER_VARARG
+ is ExpectActualIncompatibility.Modality -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_MODALITY
+ is ExpectActualIncompatibility.PropertySetterVisibility -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_PROPERTY_SETTER_VISIBILITY
+ is ExpectActualIncompatibility.Visibility -> FirErrors.EXPECT_ACTUAL_INCOMPATIBILITY_VISIBILITY
}
diff --git a/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt b/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt
index baac6d4..e8cc7ea 100644
--- a/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt
+++ b/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt
@@ -24,7 +24,7 @@
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualChecker
import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualMatcher
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualIncompatibility
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
import java.io.File
@@ -452,7 +452,7 @@
override fun onIncompatibleMembersFromClassScope(
expectSymbol: DeclarationSymbolMarker,
actualSymbol: DeclarationSymbolMarker,
- incompatibility: ExpectActualCheckingCompatibility.Incompatible<*>,
+ incompatibility: ExpectActualIncompatibility<*>,
containingExpectClassSymbol: RegularClassSymbolMarker?,
containingActualClassSymbol: RegularClassSymbolMarker?,
) {
diff --git a/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizationErrors.kt b/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizationErrors.kt
index 2e64bf1..112666b 100644
--- a/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizationErrors.kt
+++ b/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizationErrors.kt
@@ -17,7 +17,7 @@
import org.jetbrains.kotlin.ir.util.RenderIrElementVisitorForDiagnosticText
import org.jetbrains.kotlin.platform.isCommon
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualIncompatibility
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
internal object IrActualizationErrors {
@@ -26,7 +26,7 @@
val EXPECT_ACTUAL_IR_MISMATCH by error3<PsiElement, String, String, ExpectActualMatchingCompatibility.Mismatch>(
SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER
)
- val EXPECT_ACTUAL_IR_INCOMPATIBILITY by error3<PsiElement, String, String, ExpectActualCheckingCompatibility.Incompatible<*>>(
+ val EXPECT_ACTUAL_IR_INCOMPATIBILITY by error3<PsiElement, String, String, ExpectActualIncompatibility<*>>(
SourceElementPositioningStrategies.EXPECT_ACTUAL_MODIFIER
)
val ACTUAL_ANNOTATIONS_NOT_MATCH_EXPECT by warning3<PsiElement, IrSymbol, IrSymbol, ExpectActualAnnotationsIncompatibilityType<IrConstructorCall>>(
@@ -112,7 +112,7 @@
val MISMATCH = Renderer<ExpectActualMatchingCompatibility.Mismatch> {
it.reason
}
- val INCOMPATIBILITY = Renderer<ExpectActualCheckingCompatibility.Incompatible<*>> {
+ val INCOMPATIBILITY = Renderer<ExpectActualIncompatibility<*>> {
it.reason
}
val EXPECT_ACTUAL_ANNOTATION_INCOMPATIBILITY =
diff --git a/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt b/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt
index 52ca2ea..e5dd781 100644
--- a/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt
+++ b/compiler/ir/ir.actualization/src/main/kotlin/org/jetbrains/kotlin/backend/common/actualizer/IrActualizerUtils.kt
@@ -15,7 +15,7 @@
import org.jetbrains.kotlin.ir.util.*
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualAnnotationsIncompatibilityType
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualIncompatibility
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
internal fun recordActualForExpectDeclaration(
@@ -102,7 +102,7 @@
internal fun IrDiagnosticReporter.reportExpectActualIrIncompatibility(
expectSymbol: IrSymbol,
actualSymbol: IrSymbol,
- incompatibility: ExpectActualCheckingCompatibility.Incompatible<*>,
+ incompatibility: ExpectActualIncompatibility<*>,
) {
val expectDeclaration = expectSymbol.owner as IrDeclaration
val actualDeclaration = actualSymbol.owner as IrDeclaration
diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualChecker.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualChecker.kt
index 9b5138b..a48e258 100644
--- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualChecker.kt
+++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualChecker.kt
@@ -14,7 +14,7 @@
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualMatcher.matchSingleExpectAgainstPotentialActuals
import org.jetbrains.kotlin.resolve.checkers.OptInNames
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualIncompatibility
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
import org.jetbrains.kotlin.resolve.multiplatform.MemberIncompatibility
import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker
@@ -35,7 +35,7 @@
actualClassLikeSymbol: ClassLikeSymbolMarker,
context: ExpectActualMatchingContext<T>,
languageVersionSettings: LanguageVersionSettings,
- ): List<ExpectActualCheckingCompatibility.Incompatible<T>> {
+ ): List<ExpectActualIncompatibility<T>> {
val result = with(context) {
getClassifiersCompatibility(
expectClassSymbol,
@@ -45,7 +45,7 @@
)
}
@Suppress("UNCHECKED_CAST")
- return result as List<ExpectActualCheckingCompatibility.Incompatible<T>>
+ return result as List<ExpectActualIncompatibility<T>>
}
fun <T : DeclarationSymbolMarker> getCallablesCompatibility(
@@ -55,7 +55,7 @@
actualContainingClass: RegularClassSymbolMarker?,
context: ExpectActualMatchingContext<T>,
languageVersionSettings: LanguageVersionSettings,
- ): List<ExpectActualCheckingCompatibility.Incompatible<T>> = with(context) {
+ ): List<ExpectActualIncompatibility<T>> = with(context) {
val expectTypeParameters = expectContainingClass?.typeParameters.orEmpty()
val actualTypeParameters = actualContainingClass?.typeParameters.orEmpty()
val parentSubstitutor = (expectTypeParameters zipIfSizesAreEqual actualTypeParameters)
@@ -69,7 +69,7 @@
languageVersionSettings,
)
@Suppress("UNCHECKED_CAST")
- result as List<ExpectActualCheckingCompatibility.Incompatible<T>>
+ result as List<ExpectActualIncompatibility<T>>
}
fun <T : DeclarationSymbolMarker> checkSingleExpectTopLevelDeclarationAgainstMatchedActual(
@@ -96,7 +96,7 @@
actualClassLikeSymbol: ClassLikeSymbolMarker,
parentSubstitutor: TypeSubstitutorMarker?,
languageVersionSettings: LanguageVersionSettings,
- ): List<ExpectActualCheckingCompatibility.Incompatible<*>> = buildList {
+ ): List<ExpectActualIncompatibility<*>> = buildList {
// Can't check FQ names here because nested expected class may be implemented via actual typealias's expansion with the other FQ name
require(nameOf(expectClassSymbol) == nameOf(actualClassLikeSymbol)) {
"This function should be invoked only for declarations with the same name: $expectClassSymbol, $actualClassLikeSymbol"
@@ -105,37 +105,37 @@
val actualClass = computeActualClassFromPotentialActualTypealias(
expectClassSymbol,
actualClassLikeSymbol,
- onNestedTypealias = { return@getClassifiersCompatibility listOf(ExpectActualCheckingCompatibility.NestedTypeAlias) },
+ onNestedTypealias = { return@getClassifiersCompatibility listOf(ExpectActualIncompatibility.NestedTypeAlias) },
// do not report extra error on erroneous typealias
onErroneousTypealias = { return@getClassifiersCompatibility emptyList() },
)!!
if (!areCompatibleClassKinds(expectClassSymbol, actualClass)) {
- add(ExpectActualCheckingCompatibility.ClassKind)
+ add(ExpectActualIncompatibility.ClassKind)
} else {
// Don't report modality mismatch when classifiers don't match by ClassKind.
// Different classifiers might have different modality (e.g. interface vs class)
if (!areCompatibleModalities(expectClassSymbol.modality, actualClass.modality)) {
- add(ExpectActualCheckingCompatibility.Modality(expectClassSymbol.modality, actualClass.modality))
+ add(ExpectActualIncompatibility.Modality(expectClassSymbol.modality, actualClass.modality))
}
}
if (!equalBy(expectClassSymbol, actualClass) { listOf(it.isCompanion, it.isInner, it.isInlineOrValue) }) {
- add(ExpectActualCheckingCompatibility.ClassModifiers)
+ add(ExpectActualIncompatibility.ClassModifiers)
}
if (expectClassSymbol.isFun && (!actualClass.isFun || !actualClass.isSamInterface())) {
- add(ExpectActualCheckingCompatibility.FunInterfaceModifier)
+ add(ExpectActualIncompatibility.FunInterfaceModifier)
}
val expectTypeParameterSymbols = expectClassSymbol.typeParameters
val actualTypeParameterSymbols = actualClass.typeParameters
if (expectTypeParameterSymbols.size != actualTypeParameterSymbols.size) {
- add(ExpectActualCheckingCompatibility.ClassTypeParameterCount)
+ add(ExpectActualIncompatibility.ClassTypeParameterCount)
}
if (!areCompatibleClassVisibilities(expectClassSymbol, actualClass)) {
- add(ExpectActualCheckingCompatibility.Visibility)
+ add(ExpectActualIncompatibility.Visibility)
}
val substitutor = (expectTypeParameterSymbols zipIfSizesAreEqual actualTypeParameterSymbols)?.let {
@@ -143,18 +143,18 @@
}
if (substitutor != null && !areCompatibleTypeParameterUpperBounds(expectTypeParameterSymbols, actualTypeParameterSymbols, substitutor)) {
- add(ExpectActualCheckingCompatibility.ClassTypeParameterUpperBounds)
+ add(ExpectActualIncompatibility.ClassTypeParameterUpperBounds)
}
getTypeParametersVarianceOrReifiedIncompatibility(expectTypeParameterSymbols, actualTypeParameterSymbols)
?.let { add(it) }
if (substitutor != null && !areCompatibleSupertypes(expectClassSymbol, actualClass, substitutor)) {
- add(ExpectActualCheckingCompatibility.Supertypes)
+ add(ExpectActualIncompatibility.Supertypes)
}
if (isIllegalRequiresOptInAnnotation(on = actualClass, expectClassSymbol, languageVersionSettings)) {
- add(ExpectActualCheckingCompatibility.IllegalRequiresOpt)
+ add(ExpectActualIncompatibility.IllegalRequiresOpt)
}
if (substitutor != null) {
@@ -197,7 +197,7 @@
actualClassSymbol: RegularClassSymbolMarker,
substitutor: TypeSubstitutorMarker,
languageVersionSettings: LanguageVersionSettings,
- ): ExpectActualCheckingCompatibility.Incompatible<*>? {
+ ): ExpectActualIncompatibility<*>? {
val mismatchedMembers: ArrayList<Pair<DeclarationSymbolMarker, Map<ExpectActualMatchingCompatibility.Mismatch, List<DeclarationSymbolMarker?>>>> =
ArrayList()
val incompatibleMembers: ArrayList<MemberIncompatibility<*>> =
@@ -235,13 +235,13 @@
val aEntries = expectClassSymbol.collectEnumEntryNames()
val bEntries = actualClassSymbol.collectEnumEntryNames()
- if (!bEntries.containsAll(aEntries)) return ExpectActualCheckingCompatibility.EnumEntries
+ if (!bEntries.containsAll(aEntries)) return ExpectActualIncompatibility.EnumEntries
}
// TODO: check static scope?
return when (mismatchedMembers.isNotEmpty() || incompatibleMembers.isNotEmpty()) {
- true -> ExpectActualCheckingCompatibility.ClassScopes(mismatchedMembers, incompatibleMembers)
+ true -> ExpectActualIncompatibility.ClassScopes(mismatchedMembers, incompatibleMembers)
false -> null
}
}
@@ -346,7 +346,7 @@
expectContainingClass: RegularClassSymbolMarker?,
actualContainingClass: RegularClassSymbolMarker?,
languageVersionSettings: LanguageVersionSettings,
- ): List<ExpectActualCheckingCompatibility.Incompatible<*>> = buildList {
+ ): List<ExpectActualIncompatibility<*>> = buildList {
checkCallablesInvariants(expectDeclaration, actualDeclaration)
if (areEnumConstructors(expectDeclaration, actualDeclaration, expectContainingClass, actualContainingClass)) {
@@ -372,7 +372,7 @@
dynamicTypesEqualToAnything = false
)
) {
- add(ExpectActualCheckingCompatibility.ReturnType)
+ add(ExpectActualIncompatibility.ReturnType)
}
if (
@@ -380,7 +380,7 @@
expectDeclaration.hasStableParameterNames &&
sizesAreEqualAndElementsNotEqualBy(expectedValueParameters, actualValueParameters) { nameOf(it) }
) {
- add(ExpectActualCheckingCompatibility.ParameterNames)
+ add(ExpectActualIncompatibility.ParameterNames)
}
if (
@@ -389,11 +389,11 @@
expectDeclaration.hasStableParameterNames &&
sizesAreEqualAndElementsNotEqualBy(expectedContextParameters, actualContextParameters) { nameOf(it) }
) {
- add(ExpectActualCheckingCompatibility.ContextParameterNames)
+ add(ExpectActualIncompatibility.ContextParameterNames)
}
if (sizesAreEqualAndElementsNotEqualBy(expectedTypeParameters, actualTypeParameters) { nameOf(it) }) {
- add(ExpectActualCheckingCompatibility.TypeParameterNames)
+ add(ExpectActualIncompatibility.TypeParameterNames)
}
val expectModality = expectDeclaration.modality
@@ -406,7 +406,7 @@
actualContainingClass?.modality
)
) {
- add(ExpectActualCheckingCompatibility.Modality(expectModality, actualModality))
+ add(ExpectActualIncompatibility.Modality(expectModality, actualModality))
}
if (!areCompatibleCallableVisibilities(
@@ -417,7 +417,7 @@
languageVersionSettings
)
) {
- add(ExpectActualCheckingCompatibility.Visibility)
+ add(ExpectActualIncompatibility.Visibility)
}
getTypeParametersVarianceOrReifiedIncompatibility(expectedTypeParameters, actualTypeParameters)?.let { add(it) }
@@ -429,7 +429,7 @@
(actualDeclaration.isFakeOverride(actualContainingClass) || actualDeclaration.isDelegatedMember) &&
expectDeclaration.valueParameters.any { it.hasDefaultValueNonRecursive }
) {
- add(ExpectActualCheckingCompatibility.DefaultParametersInExpectActualizedByFakeOverride)
+ add(ExpectActualIncompatibility.DefaultParametersInExpectActualizedByFakeOverride)
}
if (shouldCheckDefaultParams &&
@@ -447,21 +447,21 @@
// If default params came from common supertypes of actual class and expect class then it's a valid code.
// Here we filter out such default params.
if ((actualOverriddenDeclarations - expectOverriddenDeclarations).flatMap { it.valueParameters }.any { it.hasDefaultValue }) {
- add(ExpectActualCheckingCompatibility.ActualFunctionWithDefaultParameters)
+ add(ExpectActualIncompatibility.ActualFunctionWithDefaultParameters)
}
}
if (sizesAreEqualAndElementsNotEqualBy(expectedValueParameters, actualValueParameters) { it.isVararg }) {
- add(ExpectActualCheckingCompatibility.ValueParameterVararg)
+ add(ExpectActualIncompatibility.ValueParameterVararg)
}
// Adding noinline/crossinline to parameters is disallowed, except if the expected declaration was not inline at all
if (expectDeclaration is SimpleFunctionSymbolMarker && expectDeclaration.isInline) {
if (expectedValueParameters.indices.any { i -> !expectedValueParameters[i].isNoinline && actualValueParameters[i].isNoinline }) {
- add(ExpectActualCheckingCompatibility.ValueParameterNoinline)
+ add(ExpectActualIncompatibility.ValueParameterNoinline)
}
if (expectedValueParameters.indices.any { i -> !expectedValueParameters[i].isCrossinline && actualValueParameters[i].isCrossinline }) {
- add(ExpectActualCheckingCompatibility.ValueParameterCrossinline)
+ add(ExpectActualIncompatibility.ValueParameterCrossinline)
}
}
@@ -571,14 +571,14 @@
private fun ExpectActualMatchingContext<*>.getTypeParametersVarianceOrReifiedIncompatibility(
expectTypeParameterSymbols: List<TypeParameterSymbolMarker>,
actualTypeParameterSymbols: List<TypeParameterSymbolMarker>,
- ): ExpectActualCheckingCompatibility.Incompatible<*>? {
+ ): ExpectActualIncompatibility<*>? {
if (sizesAreEqualAndElementsNotEqualBy(expectTypeParameterSymbols, actualTypeParameterSymbols) { it.variance }) {
- return ExpectActualCheckingCompatibility.TypeParameterVariance
+ return ExpectActualIncompatibility.TypeParameterVariance
}
// Removing "reified" from an expected function's type parameter is fine
if ((expectTypeParameterSymbols zipIfSizesAreEqual actualTypeParameterSymbols)?.any { (e, a) -> !e.isReified && a.isReified } == true) {
- return ExpectActualCheckingCompatibility.TypeParameterReified
+ return ExpectActualIncompatibility.TypeParameterReified
}
return null
@@ -587,9 +587,9 @@
private fun ExpectActualMatchingContext<*>.getFunctionsIncompatibility(
expectFunction: CallableSymbolMarker,
actualFunction: CallableSymbolMarker,
- ): ExpectActualCheckingCompatibility.Incompatible<*>? {
+ ): ExpectActualIncompatibility<*>? {
if (!equalBy(expectFunction, actualFunction) { f -> f.isSuspend }) {
- return ExpectActualCheckingCompatibility.FunctionModifiersDifferent
+ return ExpectActualIncompatibility.FunctionModifiersDifferent
}
if (
@@ -597,7 +597,7 @@
expectFunction.isInline && !actualFunction.isInline ||
expectFunction.isOperator && !actualFunction.isOperator
) {
- return ExpectActualCheckingCompatibility.FunctionModifiersNotSubset
+ return ExpectActualIncompatibility.FunctionModifiersNotSubset
}
return null
@@ -608,13 +608,13 @@
actual: PropertySymbolMarker,
expectContainingClass: RegularClassSymbolMarker?,
languageVersionSettings: LanguageVersionSettings,
- ): ExpectActualCheckingCompatibility.Incompatible<*>? {
+ ): ExpectActualIncompatibility<*>? {
return when {
- !equalBy(expected, actual) { p -> p.isVar } -> ExpectActualCheckingCompatibility.PropertyKind
- !equalBy(expected, actual) { p -> p.isLateinit } -> ExpectActualCheckingCompatibility.PropertyLateinitModifier
- expected.isConst && !actual.isConst -> ExpectActualCheckingCompatibility.PropertyConstModifier
+ !equalBy(expected, actual) { p -> p.isVar } -> ExpectActualIncompatibility.PropertyKind
+ !equalBy(expected, actual) { p -> p.isLateinit } -> ExpectActualIncompatibility.PropertyLateinitModifier
+ expected.isConst && !actual.isConst -> ExpectActualIncompatibility.PropertyConstModifier
!arePropertySettersWithCompatibleVisibilities(expected, actual, expectContainingClass, languageVersionSettings) ->
- ExpectActualCheckingCompatibility.PropertySetterVisibility
+ ExpectActualIncompatibility.PropertySetterVisibility
else -> null
}
}
diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt
index 87d854d..e0d6596 100644
--- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt
+++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt
@@ -13,7 +13,7 @@
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCheckingCompatibility
+import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualIncompatibility
import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualMatchingCompatibility
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.types.model.KotlinTypeMarker
@@ -162,7 +162,7 @@
fun onIncompatibleMembersFromClassScope(
expectSymbol: DeclarationSymbolMarker,
actualSymbol: DeclarationSymbolMarker,
- incompatibility: ExpectActualCheckingCompatibility.Incompatible<*>,
+ incompatibility: ExpectActualIncompatibility<*>,
containingExpectClassSymbol: RegularClassSymbolMarker?,
containingActualClassSymbol: RegularClassSymbolMarker?,
) {}
diff --git a/core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt b/core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt
index ea9493a6..cdc1ee5 100644
--- a/core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt
+++ b/core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt
@@ -14,7 +14,7 @@
* All mismatches that can be fixed by introducing an overload without this mismatch.
* In other words: "overloadable" mismatches
*
- * @see ExpectActualCheckingCompatibility
+ * @see ExpectActualIncompatibility
*/
sealed class ExpectActualMatchingCompatibility {
sealed class Mismatch(val reason: String) : ExpectActualMatchingCompatibility()
@@ -36,68 +36,79 @@
*
* @see ExpectActualMatchingCompatibility
*/
-sealed class ExpectActualCheckingCompatibility<out D> {
- sealed class Incompatible<out D>(val reason: String) : ExpectActualCheckingCompatibility<D>()
-
- object ClassTypeParameterCount : Incompatible<Nothing>(TYPE_PARAMETER_COUNT)
+sealed class ExpectActualIncompatibility<out D>(val reason: String) {
+ object ClassTypeParameterCount : ExpectActualIncompatibility<Nothing>(TYPE_PARAMETER_COUNT)
// Callables
- object ReturnType : Incompatible<Nothing>("the return types are different")
- object ParameterNames : Incompatible<Nothing>("the parameter names are different")
- object ContextParameterNames : Incompatible<Nothing>("the context parameter names are different")
- object TypeParameterNames : Incompatible<Nothing>("the names of type parameters are different")
- object ValueParameterVararg : Incompatible<Nothing>("some value parameter is vararg in one declaration and non-vararg in the other")
+ object ReturnType : ExpectActualIncompatibility<Nothing>("the return types are different")
+ object ParameterNames : ExpectActualIncompatibility<Nothing>("the parameter names are different")
+ object ContextParameterNames : ExpectActualIncompatibility<Nothing>("the context parameter names are different")
+ object TypeParameterNames : ExpectActualIncompatibility<Nothing>("the names of type parameters are different")
+ object ValueParameterVararg :
+ ExpectActualIncompatibility<Nothing>("some value parameter is vararg in one declaration and non-vararg in the other")
+
object ValueParameterNoinline :
- Incompatible<Nothing>("some value parameter is noinline in one declaration and not noinline in the other")
+ ExpectActualIncompatibility<Nothing>("some value parameter is noinline in one declaration and not noinline in the other")
+
object ValueParameterCrossinline :
- Incompatible<Nothing>("some value parameter is crossinline in one declaration and not crossinline in the other")
+ ExpectActualIncompatibility<Nothing>("some value parameter is crossinline in one declaration and not crossinline in the other")
// Functions
- object FunctionModifiersDifferent : Incompatible<Nothing>("the modifiers are different (suspend)")
+ object FunctionModifiersDifferent : ExpectActualIncompatibility<Nothing>("the modifiers are different (suspend)")
object FunctionModifiersNotSubset :
- Incompatible<Nothing>("some modifiers on 'expect' declaration are missing on the 'actual' one (infix, inline, operator)")
+ ExpectActualIncompatibility<Nothing>("some modifiers on 'expect' declaration are missing on the 'actual' one (infix, inline, operator)")
+
object ActualFunctionWithDefaultParameters :
- Incompatible<Nothing>("the 'actual' function cannot have default argument values, they should be declared in the 'expect' function")
+ ExpectActualIncompatibility<Nothing>("the 'actual' function cannot have default argument values, they should be declared in the 'expect' function")
+
object DefaultParametersInExpectActualizedByFakeOverride :
- Incompatible<Nothing>("default parameter values inside 'expect' declaration are not allowed for methods actualized via fake override")
+ ExpectActualIncompatibility<Nothing>("default parameter values inside 'expect' declaration are not allowed for methods actualized via fake override")
// Properties
- object PropertyKind : Incompatible<Nothing>("the property kinds are different (val vs var)")
- object PropertyLateinitModifier : Incompatible<Nothing>("the modifiers are different (lateinit)")
- object PropertyConstModifier : Incompatible<Nothing>("the modifiers are different (const)")
- object PropertySetterVisibility : Incompatible<Nothing>("the setter visibilities are different")
+ object PropertyKind : ExpectActualIncompatibility<Nothing>("the property kinds are different (val vs var)")
+ object PropertyLateinitModifier : ExpectActualIncompatibility<Nothing>("the modifiers are different (lateinit)")
+ object PropertyConstModifier : ExpectActualIncompatibility<Nothing>("the modifiers are different (const)")
+ object PropertySetterVisibility : ExpectActualIncompatibility<Nothing>("the setter visibilities are different")
// Classifiers
- object ClassKind : Incompatible<Nothing>("the class kinds are different (class, interface, object, enum, annotation)")
- object ClassModifiers : Incompatible<Nothing>("the modifiers are different (companion, inner, inline, value)")
- object FunInterfaceModifier : Incompatible<Nothing>("the 'actual' declaration for 'fun expect interface' is not a functional interface")
- object Supertypes : Incompatible<Nothing>("some supertypes are missing in the 'actual' declaration")
- object NestedTypeAlias : Incompatible<Nothing>("actualization by nested type alias is prohibited")
+ object ClassKind :
+ ExpectActualIncompatibility<Nothing>("the class kinds are different (class, interface, object, enum, annotation)")
+
+ object ClassModifiers : ExpectActualIncompatibility<Nothing>("the modifiers are different (companion, inner, inline, value)")
+ object FunInterfaceModifier :
+ ExpectActualIncompatibility<Nothing>("the 'actual' declaration for 'fun expect interface' is not a functional interface")
+
+ object Supertypes : ExpectActualIncompatibility<Nothing>("some supertypes are missing in the 'actual' declaration")
+ object NestedTypeAlias : ExpectActualIncompatibility<Nothing>("actualization by nested type alias is prohibited")
class ClassScopes<D>(
val mismatchedMembers: List<Pair</* expect */ D, Map<Mismatch, /* actuals */ Collection<D>>>>,
val incompatibleMembers: List<MemberIncompatibility<D>>,
- ) : Incompatible<D>("some 'expect' members have no 'actual' ones")
- object EnumEntries : Incompatible<Nothing>("some entries from 'expect enum' are missing in the 'actual enum'")
- object IllegalRequiresOpt : Incompatible<Nothing>("opt-in annotations are prohibited to be 'expect' or 'actual'. Instead, declare annotation once in common sources")
+ ) : ExpectActualIncompatibility<D>("some 'expect' members have no 'actual' ones")
+
+ object EnumEntries : ExpectActualIncompatibility<Nothing>("some entries from 'expect enum' are missing in the 'actual enum'")
+ object IllegalRequiresOpt :
+ ExpectActualIncompatibility<Nothing>("opt-in annotations are prohibited to be 'expect' or 'actual'. Instead, declare annotation once in common sources")
// Common
class Modality(
expectModality: org.jetbrains.kotlin.descriptors.Modality?,
actualModality: org.jetbrains.kotlin.descriptors.Modality?,
- ) : Incompatible<Nothing>(
+ ) : ExpectActualIncompatibility<Nothing>(
"the modalities are different ('${expectModality.toString().lowercase()}' vs '${actualModality.toString().lowercase()}')"
)
- object Visibility : Incompatible<Nothing>("the visibilities are different")
+ object Visibility : ExpectActualIncompatibility<Nothing>("the visibilities are different")
- object ClassTypeParameterUpperBounds : Incompatible<Nothing>(TYPE_PARAMETER_UPPER_BOUNDS)
- object TypeParameterVariance : Incompatible<Nothing>("declaration-site variances of type parameters are different")
- object TypeParameterReified : Incompatible<Nothing>("some type parameter is reified in one declaration and non-reified in the other")
- object Compatible : ExpectActualCheckingCompatibility<Nothing>()
+ object ClassTypeParameterUpperBounds : ExpectActualIncompatibility<Nothing>(TYPE_PARAMETER_UPPER_BOUNDS)
+ object TypeParameterVariance :
+ ExpectActualIncompatibility<Nothing>("declaration-site variances of type parameters are different")
+
+ object TypeParameterReified :
+ ExpectActualIncompatibility<Nothing>("some type parameter is reified in one declaration and non-reified in the other")
}
data class MemberIncompatibility<out D>(
val expect: D,
val actual: D,
- val incompatibility: ExpectActualCheckingCompatibility.Incompatible<D>,
+ val incompatibility: ExpectActualIncompatibility<D>,
)
