1/2 Extract K1 KMP matcher in its own subsystem. Copy files
This commit is literally this shell command: ``` cp compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualAnnotationMatchChecker.kt compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualAnnotationMatchChecker.kt cp compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/AbstractExpectActualCompatibilityChecker.kt compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1AbstractExpectActualCompatibilityChecker.kt cp compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualCollectionArgumentsCompatibilityCheckStrategy.kt compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCollectionArgumentsCompatibilityCheckStrategy.kt cp core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualCompatibility.kt compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualCompatibility.kt cp compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/mpp/ExpectActualMatchingContext.kt compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMatchingContext.kt cp core/compiler.common/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectActualMemberDiff.kt compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/K1ExpectActualMemberDiff.kt ``` Motivation: KMP is going to evolve in K2 a lot. But we don't want to touch K1 version of KMP. That's why it's easeir to just copy-paste expect-actual matcher into K1 flavor
This commit is contained in:
Nikita Bobko
+286
@@ -0,0 +1,286 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* 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
|
||||
|
||||
import org.jetbrains.kotlin.descriptors.ClassKind
|
||||
import org.jetbrains.kotlin.mpp.*
|
||||
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 {
|
||||
private val SKIPPED_CLASS_IDS = setOf(
|
||||
StandardClassIds.Annotations.Deprecated,
|
||||
StandardClassIds.Annotations.DeprecatedSinceKotlin,
|
||||
StandardClassIds.Annotations.ImplicitlyActualizedByJvmDeclaration,
|
||||
StandardClassIds.Annotations.OptionalExpectation,
|
||||
StandardClassIds.Annotations.RequireKotlin,
|
||||
StandardClassIds.Annotations.SinceKotlin,
|
||||
StandardClassIds.Annotations.Suppress,
|
||||
StandardClassIds.Annotations.WasExperimental,
|
||||
OptInNames.OPT_IN_CLASS_ID,
|
||||
)
|
||||
|
||||
class Incompatibility(
|
||||
/**
|
||||
* [expectSymbol] and [actualSymbol] are declaration symbols where annotation been mismatched.
|
||||
* They are needed for writing whole declarations in diagnostic text.
|
||||
* They are not the same as symbols passed to checker as arguments in [areAnnotationsCompatible] in following cases:
|
||||
* 1. If [actualSymbol] is typealias, it will be expanded.
|
||||
* 2. If problem is in class member, [expectSymbol] will be mismatched member, not the original class.
|
||||
* 3. If annotation mismatched on function value parameter, symbols will be whole functions, not value parameter symbols.
|
||||
*/
|
||||
val expectSymbol: DeclarationSymbolMarker,
|
||||
val actualSymbol: DeclarationSymbolMarker,
|
||||
|
||||
/**
|
||||
* Link to source code element (possibly holding null, if no source) from actual declaration
|
||||
* where mismatched actual annotation is set (or should be set if it is missing).
|
||||
* Needed for the implementation of IDE intention.
|
||||
*/
|
||||
val actualAnnotationTargetElement: SourceElementMarker,
|
||||
val type: IncompatibilityType<ExpectActualMatchingContext.AnnotationCallInfo>,
|
||||
)
|
||||
|
||||
fun areAnnotationsCompatible(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbol: DeclarationSymbolMarker,
|
||||
context: ExpectActualMatchingContext<*>,
|
||||
): Incompatibility? = with(context) {
|
||||
areAnnotationsCompatible(expectSymbol, actualSymbol)
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun areAnnotationsCompatible(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbol: DeclarationSymbolMarker,
|
||||
): Incompatibility? {
|
||||
return when (expectSymbol) {
|
||||
is CallableSymbolMarker -> {
|
||||
areCallableAnnotationsCompatible(expectSymbol, actualSymbol as CallableSymbolMarker)
|
||||
}
|
||||
is RegularClassSymbolMarker -> {
|
||||
areClassAnnotationsCompatible(expectSymbol, actualSymbol as ClassLikeSymbolMarker)
|
||||
}
|
||||
else -> error("Incorrect types: $expectSymbol $actualSymbol")
|
||||
}
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun areCallableAnnotationsCompatible(
|
||||
expectSymbol: CallableSymbolMarker,
|
||||
actualSymbol: CallableSymbolMarker,
|
||||
): Incompatibility? {
|
||||
commonForClassAndCallableChecks(expectSymbol, actualSymbol)?.let { return it }
|
||||
areAnnotationsOnValueParametersCompatible(expectSymbol, actualSymbol)?.let { return it }
|
||||
|
||||
if (expectSymbol is PropertySymbolMarker && actualSymbol is PropertySymbolMarker) {
|
||||
arePropertyGetterAndSetterAnnotationsCompatible(expectSymbol, actualSymbol)?.let { return it }
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun arePropertyGetterAndSetterAnnotationsCompatible(
|
||||
expectSymbol: PropertySymbolMarker,
|
||||
actualSymbol: PropertySymbolMarker,
|
||||
): Incompatibility? {
|
||||
listOf(
|
||||
expectSymbol.getter to actualSymbol.getter,
|
||||
expectSymbol.setter to actualSymbol.setter,
|
||||
).forEach { (expectAccessor, actualAccessor) ->
|
||||
if (expectAccessor != null && actualAccessor != null) {
|
||||
areAnnotationsSetOnDeclarationsCompatible(expectAccessor, actualAccessor)?.let {
|
||||
// Write containing declarations into diagnostic
|
||||
return Incompatibility(expectSymbol, actualSymbol, actualAccessor.getSourceElement(), it.type)
|
||||
}
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun areClassAnnotationsCompatible(
|
||||
expectSymbol: RegularClassSymbolMarker,
|
||||
actualSymbol: ClassLikeSymbolMarker,
|
||||
): Incompatibility? {
|
||||
if (actualSymbol is TypeAliasSymbolMarker) {
|
||||
val expanded = actualSymbol.expandToRegularClass() ?: return null
|
||||
return areClassAnnotationsCompatible(expectSymbol, expanded)
|
||||
}
|
||||
check(actualSymbol is RegularClassSymbolMarker)
|
||||
|
||||
commonForClassAndCallableChecks(expectSymbol, actualSymbol)?.let { return it }
|
||||
|
||||
if (checkClassScopesForAnnotationCompatibility) {
|
||||
checkAnnotationsInClassMemberScope(expectSymbol, actualSymbol)?.let { return it }
|
||||
}
|
||||
if (expectSymbol.classKind == ClassKind.ENUM_CLASS && actualSymbol.classKind == ClassKind.ENUM_CLASS) {
|
||||
checkAnnotationsOnEnumEntries(expectSymbol, actualSymbol)?.let { return it }
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun commonForClassAndCallableChecks(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbol: DeclarationSymbolMarker,
|
||||
): Incompatibility? {
|
||||
areAnnotationsSetOnDeclarationsCompatible(expectSymbol, actualSymbol)?.let { return it }
|
||||
areAnnotationsOnTypeParametersCompatible(expectSymbol, actualSymbol)?.let { return it }
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun areAnnotationsOnValueParametersCompatible(
|
||||
expectSymbol: CallableSymbolMarker,
|
||||
actualSymbol: CallableSymbolMarker,
|
||||
): Incompatibility? {
|
||||
val expectParams = expectSymbol.valueParameters
|
||||
val actualParams = actualSymbol.valueParameters
|
||||
|
||||
if (expectParams.size != actualParams.size) return null
|
||||
|
||||
return expectParams.zip(actualParams).firstNotNullOfOrNull { (expectParam, actualParam) ->
|
||||
areAnnotationsSetOnDeclarationsCompatible(expectParam, actualParam)?.let {
|
||||
// Write containing declarations into diagnostic
|
||||
Incompatibility(expectSymbol, actualSymbol, actualParam.getSourceElement(), it.type)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun areAnnotationsOnTypeParametersCompatible(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbol: DeclarationSymbolMarker,
|
||||
): Incompatibility? {
|
||||
fun DeclarationSymbolMarker.getTypeParameters(): List<TypeParameterSymbolMarker>? {
|
||||
return when (this) {
|
||||
is FunctionSymbolMarker -> typeParameters
|
||||
is RegularClassSymbolMarker -> typeParameters
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
val expectParams = expectSymbol.getTypeParameters() ?: return null
|
||||
val actualParams = actualSymbol.getTypeParameters() ?: return null
|
||||
if (expectParams.size != actualParams.size) return null
|
||||
|
||||
return expectParams.zip(actualParams).firstNotNullOfOrNull { (expectParam, actualParam) ->
|
||||
areAnnotationsSetOnDeclarationsCompatible(expectParam, actualParam)?.let {
|
||||
// Write containing declarations into diagnostic
|
||||
Incompatibility(expectSymbol, actualSymbol, actualParam.getSourceElement(), it.type)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun areAnnotationsSetOnDeclarationsCompatible(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbol: DeclarationSymbolMarker,
|
||||
): Incompatibility? {
|
||||
// TODO(Roman.Efremov, KT-60671): check annotations set on types
|
||||
|
||||
val skipSourceAnnotations = actualSymbol.hasSourceAnnotationsErased
|
||||
val actualAnnotationsByName = actualSymbol.annotations.groupBy { it.classId }
|
||||
|
||||
for (expectAnnotation in expectSymbol.annotations) {
|
||||
val expectClassId = expectAnnotation.classId ?: continue
|
||||
if (expectClassId in SKIPPED_CLASS_IDS || expectAnnotation.isOptIn) {
|
||||
continue
|
||||
}
|
||||
if (expectAnnotation.isRetentionSource && skipSourceAnnotations) {
|
||||
continue
|
||||
}
|
||||
val actualAnnotationsWithSameClassId = actualAnnotationsByName[expectClassId] ?: emptyList()
|
||||
if (actualAnnotationsWithSameClassId.isEmpty()) {
|
||||
return Incompatibility(
|
||||
expectSymbol,
|
||||
actualSymbol,
|
||||
actualSymbol.getSourceElement(),
|
||||
IncompatibilityType.MissingOnActual(expectAnnotation)
|
||||
)
|
||||
}
|
||||
val collectionCompatibilityChecker = getAnnotationCollectionArgumentsCompatibilityChecker(expectClassId)
|
||||
if (actualAnnotationsWithSameClassId.none {
|
||||
areAnnotationArgumentsEqual(expectAnnotation, it, collectionCompatibilityChecker)
|
||||
}) {
|
||||
val incompatibilityType = if (actualAnnotationsWithSameClassId.size == 1) {
|
||||
IncompatibilityType.DifferentOnActual(expectAnnotation, actualAnnotationsWithSameClassId.single())
|
||||
} else {
|
||||
// In the case of repeatable annotations, we can't choose on which to report
|
||||
IncompatibilityType.MissingOnActual(expectAnnotation)
|
||||
}
|
||||
return Incompatibility(expectSymbol, actualSymbol, actualSymbol.getSourceElement(), incompatibilityType)
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun getAnnotationCollectionArgumentsCompatibilityChecker(annotationClassId: ClassId):
|
||||
ExpectActualCollectionArgumentsCompatibilityCheckStrategy {
|
||||
return if (annotationClassId == StandardClassIds.Annotations.Target) {
|
||||
ExpectActualCollectionArgumentsCompatibilityCheckStrategy.ExpectIsSubsetOfActual
|
||||
} else {
|
||||
ExpectActualCollectionArgumentsCompatibilityCheckStrategy.Default
|
||||
}
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun checkAnnotationsInClassMemberScope(
|
||||
expectClass: RegularClassSymbolMarker,
|
||||
actualClass: RegularClassSymbolMarker,
|
||||
): Incompatibility? {
|
||||
for (actualMember in actualClass.collectAllMembers(isActualDeclaration = true)) {
|
||||
if (skipCheckingAnnotationsOfActualClassMember(actualMember)) {
|
||||
continue
|
||||
}
|
||||
val expectToCompatibilityMap = findPotentialExpectClassMembersForActual(
|
||||
expectClass, actualClass, actualMember,
|
||||
// Optimization: don't check class scopes, because:
|
||||
// 1. Annotation checker runs no matter if found expect class is compatible or not.
|
||||
// 2. Class always has at most one corresponding `expect` class (unlike for functions, which may have several overrides),
|
||||
// so we are sure that we found the right member.
|
||||
checkClassScopesCompatibility = false,
|
||||
)
|
||||
val expectMember = expectToCompatibilityMap.filter { it.value == ExpectActualCompatibility.Compatible }.keys.singleOrNull()
|
||||
// Check also incompatible members if only one is found
|
||||
?: expectToCompatibilityMap.keys.singleOrNull()
|
||||
?: continue
|
||||
areAnnotationsCompatible(expectMember, actualMember)?.let { return it }
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
context (ExpectActualMatchingContext<*>)
|
||||
private fun checkAnnotationsOnEnumEntries(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassSymbol: RegularClassSymbolMarker,
|
||||
): Incompatibility? {
|
||||
fun DeclarationSymbolMarker.getEnumEntryName(): Name =
|
||||
when (this) {
|
||||
is CallableSymbolMarker -> callableId.callableName
|
||||
is RegularClassSymbolMarker -> classId.shortClassName
|
||||
else -> error("Unexpected type $this")
|
||||
}
|
||||
|
||||
val expectEnumEntries = expectClassSymbol.collectEnumEntries()
|
||||
val actualEnumEntriesByName = actualClassSymbol.collectEnumEntries().associateBy { it.getEnumEntryName() }
|
||||
|
||||
for (expectEnumEntry in expectEnumEntries) {
|
||||
val actualEnumEntry = actualEnumEntriesByName[expectEnumEntry.getEnumEntryName()] ?: continue
|
||||
areAnnotationsSetOnDeclarationsCompatible(expectEnumEntry, actualEnumEntry)
|
||||
?.let { return it }
|
||||
}
|
||||
return null
|
||||
}
|
||||
}
|
||||
+693
@@ -0,0 +1,693 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* 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
|
||||
|
||||
import org.jetbrains.kotlin.descriptors.ClassKind
|
||||
import org.jetbrains.kotlin.descriptors.Modality
|
||||
import org.jetbrains.kotlin.descriptors.Visibilities
|
||||
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.types.model.KotlinTypeMarker
|
||||
import org.jetbrains.kotlin.types.model.TypeSubstitutorMarker
|
||||
import org.jetbrains.kotlin.utils.SmartList
|
||||
import org.jetbrains.kotlin.utils.addToStdlib.enumMapOf
|
||||
import org.jetbrains.kotlin.utils.addToStdlib.enumSetOf
|
||||
import org.jetbrains.kotlin.utils.keysToMap
|
||||
import java.util.*
|
||||
|
||||
object AbstractExpectActualCompatibilityChecker {
|
||||
fun <T : DeclarationSymbolMarker> getClassifiersCompatibility(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassLikeSymbol: ClassLikeSymbolMarker,
|
||||
checkClassScopesCompatibility: Boolean,
|
||||
context: ExpectActualMatchingContext<T>,
|
||||
): ExpectActualCompatibility<T> {
|
||||
val result = with(context) {
|
||||
getClassifiersCompatibility(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor = null, checkClassScopesCompatibility)
|
||||
}
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return result as ExpectActualCompatibility<T>
|
||||
}
|
||||
|
||||
fun <T : DeclarationSymbolMarker> getCallablesCompatibility(
|
||||
expectDeclaration: CallableSymbolMarker,
|
||||
actualDeclaration: CallableSymbolMarker,
|
||||
parentSubstitutor: TypeSubstitutorMarker?,
|
||||
expectContainingClass: RegularClassSymbolMarker?,
|
||||
actualContainingClass: RegularClassSymbolMarker?,
|
||||
context: ExpectActualMatchingContext<T>,
|
||||
): ExpectActualCompatibility<T> {
|
||||
val result = with(context) {
|
||||
getCallablesCompatibility(expectDeclaration, actualDeclaration, parentSubstitutor, expectContainingClass, actualContainingClass)
|
||||
}
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
return result as ExpectActualCompatibility<T>
|
||||
}
|
||||
|
||||
fun <T : DeclarationSymbolMarker> matchSingleExpectTopLevelDeclarationAgainstPotentialActuals(
|
||||
expectDeclaration: DeclarationSymbolMarker,
|
||||
actualDeclarations: List<DeclarationSymbolMarker>,
|
||||
context: ExpectActualMatchingContext<T>,
|
||||
) {
|
||||
with(context) {
|
||||
matchSingleExpectAgainstPotentialActuals(
|
||||
expectDeclaration,
|
||||
actualDeclarations,
|
||||
substitutor = null,
|
||||
expectClassSymbol = null,
|
||||
actualClassSymbol = null,
|
||||
unfulfilled = null,
|
||||
checkClassScopesCompatibility = true,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
@Suppress("warnings")
|
||||
private fun getClassifiersCompatibility(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassLikeSymbol: ClassLikeSymbolMarker,
|
||||
parentSubstitutor: TypeSubstitutorMarker?,
|
||||
checkClassScopes: Boolean,
|
||||
): ExpectActualCompatibility<*> = getClassifiersIncompatibility(expectClassSymbol, actualClassLikeSymbol, parentSubstitutor, checkClassScopes)
|
||||
?: ExpectActualCompatibility.Compatible
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
@Suppress("warnings")
|
||||
private fun getClassifiersIncompatibility(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassLikeSymbol: ClassLikeSymbolMarker,
|
||||
parentSubstitutor: TypeSubstitutorMarker?,
|
||||
checkClassScopesCompatibility: Boolean,
|
||||
): ExpectActualCompatibility.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) {
|
||||
"This function should be invoked only for declarations with the same name: $expectClassSymbol, $actualClassLikeSymbol"
|
||||
}
|
||||
|
||||
val actualClass = when (actualClassLikeSymbol) {
|
||||
is RegularClassSymbolMarker -> actualClassLikeSymbol
|
||||
is TypeAliasSymbolMarker -> actualClassLikeSymbol.expandToRegularClass()
|
||||
?: return null // do not report extra error on erroneous typealias
|
||||
else -> error("Incorrect actual classifier for $expectClassSymbol: $actualClassLikeSymbol")
|
||||
}
|
||||
|
||||
if (!areCompatibleClassKinds(expectClassSymbol, actualClass)) return Incompatible.ClassKind
|
||||
|
||||
if (!equalBy(expectClassSymbol, actualClass) { listOf(it.isCompanion, it.isInner, it.isInline || it.isValue) }) {
|
||||
return Incompatible.ClassModifiers
|
||||
}
|
||||
|
||||
if (expectClassSymbol.isFun && !actualClass.isFun && actualClass.isNotSamInterface()) {
|
||||
return Incompatible.FunInterfaceModifier
|
||||
}
|
||||
|
||||
val expectTypeParameterSymbols = expectClassSymbol.typeParameters
|
||||
val actualTypeParameterSymbols = actualClass.typeParameters
|
||||
if (expectTypeParameterSymbols.size != actualTypeParameterSymbols.size) {
|
||||
return Incompatible.ClassTypeParameterCount
|
||||
}
|
||||
|
||||
if (!areCompatibleModalities(expectClassSymbol.modality, actualClass.modality)) {
|
||||
return Incompatible.Modality
|
||||
}
|
||||
|
||||
if (!areCompatibleClassVisibilities(expectClassSymbol, actualClass)) {
|
||||
return Incompatible.Visibility
|
||||
}
|
||||
|
||||
val substitutor = createExpectActualTypeParameterSubstitutor(
|
||||
expectTypeParameterSymbols,
|
||||
actualTypeParameterSymbols,
|
||||
parentSubstitutor
|
||||
)
|
||||
|
||||
if (!areCompatibleTypeParameterUpperBounds(expectTypeParameterSymbols, actualTypeParameterSymbols, substitutor)) {
|
||||
return Incompatible.ClassTypeParameterUpperBounds
|
||||
}
|
||||
|
||||
getTypeParametersVarianceOrReifiedIncompatibility(expectTypeParameterSymbols, actualTypeParameterSymbols)
|
||||
?.let { return it }
|
||||
|
||||
if (!areCompatibleSupertypes(expectClassSymbol, actualClass, substitutor)) {
|
||||
return Incompatible.Supertypes
|
||||
}
|
||||
|
||||
if (checkClassScopesCompatibility) {
|
||||
getClassScopesIncompatibility(expectClassSymbol, actualClass, substitutor)?.let { return it }
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleSupertypes(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassSymbol: RegularClassSymbolMarker,
|
||||
substitutor: TypeSubstitutorMarker,
|
||||
): Boolean {
|
||||
return when (allowTransitiveSupertypesActualization) {
|
||||
false -> areCompatibleSupertypesOneByOne(expectClassSymbol, actualClassSymbol, substitutor)
|
||||
true -> areCompatibleSupertypesTransitive(expectClassSymbol, actualClassSymbol, substitutor)
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleSupertypesOneByOne(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassSymbol: RegularClassSymbolMarker,
|
||||
substitutor: TypeSubstitutorMarker,
|
||||
): Boolean {
|
||||
// Subtract kotlin.Any from supertypes because it's implicitly added if no explicit supertype is specified,
|
||||
// and not added if an explicit supertype _is_ specified
|
||||
val expectSupertypes = expectClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
|
||||
val actualSupertypes = actualClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
|
||||
return expectSupertypes.all { expectSupertype ->
|
||||
val substitutedExpectType = substitutor.safeSubstitute(expectSupertype)
|
||||
actualSupertypes.any { actualSupertype ->
|
||||
areCompatibleExpectActualTypes(substitutedExpectType, actualSupertype)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleSupertypesTransitive(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassSymbol: RegularClassSymbolMarker,
|
||||
substitutor: TypeSubstitutorMarker,
|
||||
): Boolean {
|
||||
val expectSupertypes = expectClassSymbol.superTypes.filterNot { it.typeConstructor().isAnyConstructor() }
|
||||
val actualType = actualClassSymbol.defaultType
|
||||
return expectSupertypes.all { expectSupertype ->
|
||||
actualTypeIsSubtypeOfExpectType(
|
||||
expectType = substitutor.safeSubstitute(expectSupertype),
|
||||
actualType = actualType
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getClassScopesIncompatibility(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassSymbol: RegularClassSymbolMarker,
|
||||
substitutor: TypeSubstitutorMarker,
|
||||
): Incompatible.WeakIncompatible<*>? {
|
||||
val unfulfilled = arrayListOf<Pair<DeclarationSymbolMarker, Map<Incompatible<*>, List<DeclarationSymbolMarker?>>>>()
|
||||
|
||||
val actualMembersByName = actualClassSymbol.collectAllMembers(isActualDeclaration = true).groupBy { it.name }
|
||||
|
||||
outer@ for (expectMember in expectClassSymbol.collectAllMembers(isActualDeclaration = false)) {
|
||||
if (expectMember is CallableSymbolMarker && expectMember.shouldSkipMatching(expectClassSymbol)) continue
|
||||
|
||||
val actualMembers = actualMembersByName[expectMember.name]?.filter { actualMember ->
|
||||
expectMember is CallableSymbolMarker && actualMember is CallableSymbolMarker ||
|
||||
expectMember is RegularClassSymbolMarker && actualMember is RegularClassSymbolMarker
|
||||
}.orEmpty()
|
||||
|
||||
matchSingleExpectAgainstPotentialActuals(
|
||||
expectMember,
|
||||
actualMembers,
|
||||
substitutor,
|
||||
expectClassSymbol,
|
||||
actualClassSymbol,
|
||||
unfulfilled,
|
||||
checkClassScopesCompatibility = true,
|
||||
)
|
||||
}
|
||||
|
||||
if (expectClassSymbol.classKind == ClassKind.ENUM_CLASS) {
|
||||
val aEntries = expectClassSymbol.collectEnumEntryNames()
|
||||
val bEntries = actualClassSymbol.collectEnumEntryNames()
|
||||
|
||||
if (!bEntries.containsAll(aEntries)) return Incompatible.EnumEntries
|
||||
}
|
||||
|
||||
// TODO: check static scope?
|
||||
|
||||
if (unfulfilled.isEmpty()) return null
|
||||
|
||||
return Incompatible.ClassScopes(unfulfilled)
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun matchSingleExpectAgainstPotentialActuals(
|
||||
expectMember: DeclarationSymbolMarker,
|
||||
actualMembers: List<DeclarationSymbolMarker>,
|
||||
substitutor: TypeSubstitutorMarker?,
|
||||
expectClassSymbol: RegularClassSymbolMarker?,
|
||||
actualClassSymbol: RegularClassSymbolMarker?,
|
||||
unfulfilled: MutableList<Pair<DeclarationSymbolMarker, Map<Incompatible<*>, List<DeclarationSymbolMarker?>>>>?,
|
||||
checkClassScopesCompatibility: Boolean,
|
||||
) {
|
||||
val mapping = actualMembers.keysToMap { actualMember ->
|
||||
when (expectMember) {
|
||||
is CallableSymbolMarker -> getCallablesCompatibility(
|
||||
expectMember,
|
||||
actualMember as CallableSymbolMarker,
|
||||
substitutor,
|
||||
expectClassSymbol,
|
||||
actualClassSymbol
|
||||
)
|
||||
|
||||
is RegularClassSymbolMarker -> {
|
||||
val parentSubstitutor = substitutor?.takeIf { !innerClassesCapturesOuterTypeParameters }
|
||||
getClassifiersCompatibility(
|
||||
expectMember,
|
||||
actualMember as ClassLikeSymbolMarker,
|
||||
parentSubstitutor,
|
||||
checkClassScopesCompatibility,
|
||||
)
|
||||
}
|
||||
else -> error("Unsupported declaration: $expectMember ($actualMembers)")
|
||||
}
|
||||
}
|
||||
|
||||
val incompatibilityMap = mutableMapOf<Incompatible<*>, MutableList<DeclarationSymbolMarker>>()
|
||||
for ((actualMember, compatibility) in mapping) {
|
||||
when (compatibility) {
|
||||
ExpectActualCompatibility.Compatible -> {
|
||||
onMatchedMembers(expectMember, actualMember, expectClassSymbol, actualClassSymbol)
|
||||
return
|
||||
}
|
||||
|
||||
is Incompatible -> incompatibilityMap.getOrPut(compatibility) { SmartList() }.add(actualMember)
|
||||
}
|
||||
}
|
||||
|
||||
unfulfilled?.add(expectMember to incompatibilityMap)
|
||||
onMismatchedMembersFromClassScope(expectMember, incompatibilityMap, expectClassSymbol, actualClassSymbol)
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getCallablesCompatibility(
|
||||
expectDeclaration: CallableSymbolMarker,
|
||||
actualDeclaration: CallableSymbolMarker,
|
||||
parentSubstitutor: TypeSubstitutorMarker?,
|
||||
expectContainingClass: RegularClassSymbolMarker?,
|
||||
actualContainingClass: RegularClassSymbolMarker?,
|
||||
): ExpectActualCompatibility<*> {
|
||||
require(
|
||||
(expectDeclaration is ConstructorSymbolMarker && actualDeclaration is ConstructorSymbolMarker) ||
|
||||
expectDeclaration.callableId.callableName == actualDeclaration.callableId.callableName
|
||||
) {
|
||||
"This function should be invoked only for declarations with the same name: $expectDeclaration, $actualDeclaration"
|
||||
}
|
||||
require((expectDeclaration.dispatchReceiverType == null) == (actualDeclaration.dispatchReceiverType == null)) {
|
||||
"This function should be invoked only for declarations in the same kind of container (both members or both top level): $expectDeclaration, $actualDeclaration"
|
||||
}
|
||||
|
||||
if (
|
||||
enumConstructorsAreAlwaysCompatible &&
|
||||
expectContainingClass?.classKind == ClassKind.ENUM_CLASS &&
|
||||
actualContainingClass?.classKind == ClassKind.ENUM_CLASS &&
|
||||
expectDeclaration is ConstructorSymbolMarker &&
|
||||
actualDeclaration is ConstructorSymbolMarker
|
||||
) {
|
||||
return ExpectActualCompatibility.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
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getCallablesStrongIncompatibility(
|
||||
expectDeclaration: CallableSymbolMarker,
|
||||
actualDeclaration: CallableSymbolMarker,
|
||||
parentSubstitutor: TypeSubstitutorMarker?,
|
||||
): Incompatible.StrongIncompatible<*>? {
|
||||
if (expectDeclaration is FunctionSymbolMarker != actualDeclaration is FunctionSymbolMarker) {
|
||||
return Incompatible.CallableKind
|
||||
}
|
||||
|
||||
val expectedReceiverType = expectDeclaration.extensionReceiverType
|
||||
val actualReceiverType = actualDeclaration.extensionReceiverType
|
||||
if ((expectedReceiverType != null) != (actualReceiverType != null)) {
|
||||
return Incompatible.ParameterShape
|
||||
}
|
||||
|
||||
val expectedValueParameters = expectDeclaration.valueParameters
|
||||
val actualValueParameters = actualDeclaration.valueParameters
|
||||
if (!valueParametersCountCompatible(expectDeclaration, actualDeclaration, expectedValueParameters, actualValueParameters)) {
|
||||
return Incompatible.ParameterCount
|
||||
}
|
||||
|
||||
val expectedTypeParameters = expectDeclaration.typeParameters
|
||||
val actualTypeParameters = actualDeclaration.typeParameters
|
||||
if (expectedTypeParameters.size != actualTypeParameters.size) {
|
||||
return Incompatible.FunctionTypeParameterCount
|
||||
}
|
||||
|
||||
val substitutor = createExpectActualTypeParameterSubstitutor(
|
||||
expectedTypeParameters,
|
||||
actualTypeParameters,
|
||||
parentSubstitutor
|
||||
)
|
||||
|
||||
if (
|
||||
!areCompatibleTypeLists(
|
||||
expectedValueParameters.toTypeList(substitutor),
|
||||
actualValueParameters.toTypeList(createEmptySubstitutor())
|
||||
) ||
|
||||
!areCompatibleExpectActualTypes(
|
||||
expectedReceiverType?.let { substitutor.safeSubstitute(it) },
|
||||
actualReceiverType
|
||||
)
|
||||
) {
|
||||
return Incompatible.ParameterTypes
|
||||
}
|
||||
|
||||
if (shouldCheckReturnTypesOfCallables) {
|
||||
if (!areCompatibleExpectActualTypes(substitutor.safeSubstitute(expectDeclaration.returnType), actualDeclaration.returnType)) {
|
||||
return Incompatible.ReturnType
|
||||
}
|
||||
}
|
||||
|
||||
if (!areCompatibleTypeParameterUpperBounds(expectedTypeParameters, actualTypeParameters, substitutor)) {
|
||||
return Incompatible.FunctionTypeParameterUpperBounds
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getCallablesWeakIncompatibility(
|
||||
expectDeclaration: CallableSymbolMarker,
|
||||
actualDeclaration: CallableSymbolMarker,
|
||||
expectContainingClass: RegularClassSymbolMarker?,
|
||||
actualContainingClass: RegularClassSymbolMarker?,
|
||||
): Incompatible.WeakIncompatible<*>? {
|
||||
val expectedTypeParameters = expectDeclaration.typeParameters
|
||||
val actualTypeParameters = actualDeclaration.typeParameters
|
||||
val expectedValueParameters = expectDeclaration.valueParameters
|
||||
val actualValueParameters = actualDeclaration.valueParameters
|
||||
|
||||
if (actualDeclaration.hasStableParameterNames && !equalsBy(expectedValueParameters, actualValueParameters) { it.name }) {
|
||||
return Incompatible.ParameterNames
|
||||
}
|
||||
|
||||
if (!equalsBy(expectedTypeParameters, actualTypeParameters) { it.name }) {
|
||||
return Incompatible.TypeParameterNames
|
||||
}
|
||||
|
||||
val expectModality = expectDeclaration.modality
|
||||
val actualModality = actualDeclaration.modality
|
||||
if (
|
||||
!areCompatibleModalities(
|
||||
expectModality,
|
||||
actualModality,
|
||||
expectContainingClass?.modality,
|
||||
actualContainingClass?.modality
|
||||
)
|
||||
) {
|
||||
return Incompatible.Modality
|
||||
}
|
||||
|
||||
if (!areCompatibleCallableVisibilities(expectDeclaration.visibility, expectModality, actualDeclaration.visibility)) {
|
||||
return Incompatible.Visibility
|
||||
}
|
||||
|
||||
getTypeParametersVarianceOrReifiedIncompatibility(expectedTypeParameters, actualTypeParameters)?.let { return it }
|
||||
|
||||
if (shouldCheckAbsenceOfDefaultParamsInActual) {
|
||||
// "Default parameters in actual" check is required only for functions, because only functions can have parameters
|
||||
if (actualDeclaration is FunctionSymbolMarker && expectDeclaration is FunctionSymbolMarker) {
|
||||
// Actual annotation constructors can have default argument values; their consistency with arguments in the expected annotation
|
||||
// is checked in ExpectedActualDeclarationChecker.checkAnnotationConstructors
|
||||
if (!actualDeclaration.isAnnotationConstructor() &&
|
||||
// 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.
|
||||
(actualDeclaration.allOverriddenDeclarationsRecursive() - expectDeclaration.allOverriddenDeclarationsRecursive().toSet())
|
||||
.flatMap { it.valueParameters }.any { it.hasDefaultValue }
|
||||
) {
|
||||
return Incompatible.ActualFunctionWithDefaultParameters
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!equalsBy(expectedValueParameters, actualValueParameters) { it.isVararg }) {
|
||||
return Incompatible.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 }) {
|
||||
return Incompatible.ValueParameterNoinline
|
||||
}
|
||||
if (expectedValueParameters.indices.any { i -> !expectedValueParameters[i].isCrossinline && actualValueParameters[i].isCrossinline }) {
|
||||
return Incompatible.ValueParameterCrossinline
|
||||
}
|
||||
}
|
||||
|
||||
when {
|
||||
expectDeclaration is FunctionSymbolMarker && actualDeclaration is FunctionSymbolMarker ->
|
||||
getFunctionsIncompatibility(expectDeclaration, actualDeclaration)?.let { return it }
|
||||
|
||||
expectDeclaration is PropertySymbolMarker && actualDeclaration is PropertySymbolMarker ->
|
||||
getPropertiesIncompatibility(expectDeclaration, actualDeclaration)?.let { return it }
|
||||
|
||||
expectDeclaration is EnumEntrySymbolMarker && actualDeclaration is EnumEntrySymbolMarker -> {
|
||||
// do nothing, entries are matched only by name
|
||||
}
|
||||
|
||||
else -> error("Unsupported declarations: $expectDeclaration, $actualDeclaration")
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun valueParametersCountCompatible(
|
||||
expectDeclaration: CallableSymbolMarker,
|
||||
actualDeclaration: CallableSymbolMarker,
|
||||
expectValueParameters: List<ValueParameterSymbolMarker>,
|
||||
actualValueParameters: List<ValueParameterSymbolMarker>,
|
||||
): Boolean {
|
||||
if (expectValueParameters.size == actualValueParameters.size) return true
|
||||
|
||||
return if (expectDeclaration.isAnnotationConstructor() && actualDeclaration.isAnnotationConstructor()) {
|
||||
expectValueParameters.isEmpty() && actualValueParameters.all { it.hasDefaultValue }
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleTypeLists(
|
||||
expectedTypes: List<KotlinTypeMarker?>,
|
||||
actualTypes: List<KotlinTypeMarker?>,
|
||||
): Boolean {
|
||||
for (i in expectedTypes.indices) {
|
||||
if (!areCompatibleExpectActualTypes(expectedTypes[i], actualTypes[i])) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleClassKinds(
|
||||
expectClass: RegularClassSymbolMarker,
|
||||
actualClass: RegularClassSymbolMarker,
|
||||
): Boolean {
|
||||
if (expectClass.classKind == actualClass.classKind) return true
|
||||
|
||||
if (expectClass.classKind == ClassKind.CLASS && expectClass.isFinal && expectClass.isCtorless) {
|
||||
if (actualClass.classKind == ClassKind.OBJECT) return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
private fun areCompatibleModalities(
|
||||
expectModality: Modality?,
|
||||
actualModality: Modality?,
|
||||
expectContainingClassModality: Modality? = null,
|
||||
actualContainingClassModality: Modality? = null,
|
||||
): Boolean {
|
||||
val expectEffectiveModality = effectiveModality(expectModality, expectContainingClassModality)
|
||||
val actualEffectiveModality = effectiveModality(actualModality, actualContainingClassModality)
|
||||
|
||||
return actualEffectiveModality in compatibleModalityMap.getValue(expectEffectiveModality)
|
||||
}
|
||||
|
||||
/*
|
||||
* If containing class is final then all declarations in it effectively final
|
||||
*/
|
||||
private fun effectiveModality(declarationModality: Modality?, containingClassModality: Modality?): Modality? {
|
||||
return when (containingClassModality) {
|
||||
Modality.FINAL -> Modality.FINAL
|
||||
else -> declarationModality
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Key is expect modality, value is a set of compatible actual modalities
|
||||
*/
|
||||
private val compatibleModalityMap: EnumMap<Modality, EnumSet<Modality>> = enumMapOf(
|
||||
Modality.ABSTRACT to enumSetOf(Modality.ABSTRACT),
|
||||
Modality.OPEN to enumSetOf(Modality.OPEN),
|
||||
Modality.FINAL to enumSetOf(Modality.OPEN, Modality.FINAL),
|
||||
Modality.SEALED to enumSetOf(Modality.SEALED),
|
||||
)
|
||||
|
||||
private fun areCompatibleCallableVisibilities(
|
||||
expectVisibility: Visibility,
|
||||
expectModality: Modality?,
|
||||
actualVisibility: Visibility,
|
||||
): Boolean {
|
||||
val compare = Visibilities.compare(expectVisibility, actualVisibility)
|
||||
return if (expectModality != Modality.FINAL) {
|
||||
// For overridable declarations visibility should match precisely, see KT-19664
|
||||
compare == 0
|
||||
} else {
|
||||
// For non-overridable declarations actuals are allowed to have more permissive visibility
|
||||
compare != null && compare <= 0
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleClassVisibilities(
|
||||
expectClassSymbol: RegularClassSymbolMarker,
|
||||
actualClassSymbol: RegularClassSymbolMarker,
|
||||
): Boolean {
|
||||
val expectVisibility = expectClassSymbol.visibility
|
||||
val actualVisibility = actualClassSymbol.visibility
|
||||
if (expectVisibility == actualVisibility) return true
|
||||
if (!allowClassActualizationWithWiderVisibility) return false
|
||||
val result = Visibilities.compare(actualVisibility, expectVisibility)
|
||||
return result != null && result > 0
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun areCompatibleTypeParameterUpperBounds(
|
||||
expectTypeParameterSymbols: List<TypeParameterSymbolMarker>,
|
||||
actualTypeParameterSymbols: List<TypeParameterSymbolMarker>,
|
||||
substitutor: TypeSubstitutorMarker,
|
||||
): Boolean {
|
||||
for (i in expectTypeParameterSymbols.indices) {
|
||||
val expectBounds = expectTypeParameterSymbols[i].bounds
|
||||
val actualBounds = actualTypeParameterSymbols[i].bounds
|
||||
if (
|
||||
expectBounds.size != actualBounds.size ||
|
||||
!areCompatibleTypeLists(expectBounds.map { substitutor.safeSubstitute(it) }, actualBounds)
|
||||
) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getTypeParametersVarianceOrReifiedIncompatibility(
|
||||
expectTypeParameterSymbols: List<TypeParameterSymbolMarker>,
|
||||
actualTypeParameterSymbols: List<TypeParameterSymbolMarker>,
|
||||
): Incompatible.WeakIncompatible<*>? {
|
||||
if (!equalsBy(expectTypeParameterSymbols, actualTypeParameterSymbols) { it.variance }) {
|
||||
return Incompatible.TypeParameterVariance
|
||||
}
|
||||
|
||||
// Removing "reified" from an expected function's type parameter is fine
|
||||
if (
|
||||
expectTypeParameterSymbols.indices.any { i ->
|
||||
!expectTypeParameterSymbols[i].isReified && actualTypeParameterSymbols[i].isReified
|
||||
}
|
||||
) {
|
||||
return Incompatible.TypeParameterReified
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getFunctionsIncompatibility(
|
||||
expectFunction: CallableSymbolMarker,
|
||||
actualFunction: CallableSymbolMarker,
|
||||
): Incompatible.WeakIncompatible<*>? {
|
||||
if (!equalBy(expectFunction, actualFunction) { f -> f.isSuspend }) {
|
||||
return Incompatible.FunctionModifiersDifferent
|
||||
}
|
||||
|
||||
if (
|
||||
expectFunction.isInfix && !actualFunction.isInfix ||
|
||||
expectFunction.isInline && !actualFunction.isInline ||
|
||||
expectFunction.isOperator && !actualFunction.isOperator
|
||||
) {
|
||||
return Incompatible.FunctionModifiersNotSubset
|
||||
}
|
||||
|
||||
return null
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun getPropertiesIncompatibility(
|
||||
expected: PropertySymbolMarker,
|
||||
actual: PropertySymbolMarker,
|
||||
): Incompatible.WeakIncompatible<*>? {
|
||||
return when {
|
||||
!equalBy(expected, actual) { p -> p.isVar } -> Incompatible.PropertyKind
|
||||
!equalBy(expected, actual) { p -> p.isLateinit } -> Incompatible.PropertyLateinitModifier
|
||||
expected.isConst && !actual.isConst -> Incompatible.PropertyConstModifier
|
||||
!arePropertySettersWithCompatibleVisibilities(expected, actual) -> Incompatible.PropertySetterVisibility
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun arePropertySettersWithCompatibleVisibilities(
|
||||
expected: PropertySymbolMarker,
|
||||
actual: PropertySymbolMarker,
|
||||
): Boolean {
|
||||
val expectedSetter = expected.setter ?: return true
|
||||
val actualSetter = actual.setter ?: return true
|
||||
return areCompatibleCallableVisibilities(expectedSetter.visibility, expectedSetter.modality, actualSetter.visibility)
|
||||
}
|
||||
|
||||
// ---------------------------------------- Utils ----------------------------------------
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private fun List<ValueParameterSymbolMarker>.toTypeList(substitutor: TypeSubstitutorMarker): List<KotlinTypeMarker> {
|
||||
return this.map { substitutor.safeSubstitute(it.returnType) }
|
||||
}
|
||||
|
||||
private inline fun <T, K> equalsBy(first: List<T>, second: List<T>, selector: (T) -> K): Boolean {
|
||||
for (i in first.indices) {
|
||||
if (selector(first[i]) != selector(second[i])) return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
private inline fun <T, K> equalBy(first: T, second: T, selector: (T) -> K): Boolean =
|
||||
selector(first) == selector(second)
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private val DeclarationSymbolMarker.name: Name
|
||||
get() = when (this) {
|
||||
is ConstructorSymbolMarker -> SpecialNames.INIT
|
||||
is ValueParameterSymbolMarker -> parameterName
|
||||
is CallableSymbolMarker -> callableId.callableName
|
||||
is RegularClassSymbolMarker -> classId.shortClassName
|
||||
is TypeAliasSymbolMarker -> classId.shortClassName
|
||||
is TypeParameterSymbolMarker -> parameterName
|
||||
else -> error("Unsupported declaration: $this")
|
||||
}
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private val RegularClassSymbolMarker.isCtorless: Boolean
|
||||
get() = getMembersForExpectClass(SpecialNames.INIT).isEmpty()
|
||||
|
||||
context(ExpectActualMatchingContext<*>)
|
||||
private val RegularClassSymbolMarker.isFinal: Boolean
|
||||
get() = modality == Modality.FINAL
|
||||
}
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* 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
|
||||
|
||||
|
||||
sealed class ExpectActualCollectionArgumentsCompatibilityCheckStrategy {
|
||||
abstract fun <T> areCompatible(
|
||||
expectArg: Collection<T>,
|
||||
actualArg: Collection<T>,
|
||||
elementsEqual: (T, T) -> Boolean,
|
||||
): Boolean
|
||||
|
||||
data object Default : ExpectActualCollectionArgumentsCompatibilityCheckStrategy() {
|
||||
override fun <T> areCompatible(
|
||||
expectArg: Collection<T>,
|
||||
actualArg: Collection<T>,
|
||||
elementsEqual: (T, T) -> Boolean,
|
||||
): Boolean {
|
||||
return expectArg.size == actualArg.size && expectArg.zip(actualArg).all { (e1, e2) -> elementsEqual(e1, e2) }
|
||||
}
|
||||
}
|
||||
|
||||
internal data object ExpectIsSubsetOfActual : ExpectActualCollectionArgumentsCompatibilityCheckStrategy() {
|
||||
override fun <T> areCompatible(
|
||||
expectArg: Collection<T>,
|
||||
actualArg: Collection<T>,
|
||||
elementsEqual: (T, T) -> Boolean,
|
||||
): Boolean {
|
||||
return expectArg.all { e1 ->
|
||||
actualArg.any { e2 -> elementsEqual(e1, e2) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+115
@@ -0,0 +1,115 @@
|
||||
/*
|
||||
* Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* 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.multiplatform
|
||||
|
||||
import kotlin.contracts.ExperimentalContracts
|
||||
import kotlin.contracts.contract
|
||||
|
||||
sealed class ExpectActualCompatibility<out D> {
|
||||
|
||||
// Note that the reason is used in the diagnostic output, see PlatformIncompatibilityDiagnosticRenderer
|
||||
sealed class Incompatible<out D>(val reason: String?) : ExpectActualCompatibility<D>() {
|
||||
|
||||
sealed class WeakIncompatible<out D>(reason: String?) : Incompatible<D>(reason)
|
||||
|
||||
// For StrongIncompatible `actual` declaration is considered as overload and error reports on expected declaration
|
||||
sealed class StrongIncompatible<out D>(reason: String?) : Incompatible<D>(reason)
|
||||
|
||||
// Callables
|
||||
|
||||
object CallableKind : StrongIncompatible<Nothing>("callable kinds are different (function vs property)")
|
||||
|
||||
object ParameterShape : StrongIncompatible<Nothing>("parameter shapes are different (extension vs non-extension)")
|
||||
|
||||
object ParameterCount : StrongIncompatible<Nothing>("number of value parameters is different")
|
||||
|
||||
// FunctionTypeParameterCount is strong because functions can be overloaded by type parameter count
|
||||
object FunctionTypeParameterCount : StrongIncompatible<Nothing>("number of type parameters is different")
|
||||
|
||||
// ClassTypeParameterCount is weak because classes cannot be overloaded
|
||||
object ClassTypeParameterCount : WeakIncompatible<Nothing>(FunctionTypeParameterCount.reason)
|
||||
|
||||
object ParameterTypes : StrongIncompatible<Nothing>("parameter types are different")
|
||||
object ReturnType : StrongIncompatible<Nothing>("return type is different")
|
||||
|
||||
object ParameterNames : WeakIncompatible<Nothing>("parameter names are different")
|
||||
object TypeParameterNames : WeakIncompatible<Nothing>("names of type parameters are different")
|
||||
|
||||
object ValueParameterVararg : WeakIncompatible<Nothing>("some value parameter is vararg in one declaration and non-vararg in the other")
|
||||
object ValueParameterNoinline : WeakIncompatible<Nothing>(
|
||||
"some value parameter is noinline in one declaration and not noinline in the other"
|
||||
)
|
||||
|
||||
object ValueParameterCrossinline : WeakIncompatible<Nothing>(
|
||||
"some value parameter is crossinline in one declaration and not crossinline in the other"
|
||||
)
|
||||
|
||||
// Functions
|
||||
|
||||
object FunctionModifiersDifferent : WeakIncompatible<Nothing>("modifiers are different (suspend)")
|
||||
object FunctionModifiersNotSubset : WeakIncompatible<Nothing>(
|
||||
"some modifiers on expected declaration are missing on the actual one (infix, inline, operator)"
|
||||
)
|
||||
object ActualFunctionWithDefaultParameters :
|
||||
WeakIncompatible<Nothing>("actual function cannot have default argument values, they should be declared in the expected function")
|
||||
|
||||
// Properties
|
||||
|
||||
object PropertyKind : WeakIncompatible<Nothing>("property kinds are different (val vs var)")
|
||||
object PropertyLateinitModifier : WeakIncompatible<Nothing>("modifiers are different (lateinit)")
|
||||
object PropertyConstModifier : WeakIncompatible<Nothing>("modifiers are different (const)")
|
||||
object PropertySetterVisibility : WeakIncompatible<Nothing>("setter visibility is different")
|
||||
|
||||
// Classifiers
|
||||
|
||||
object ClassKind : WeakIncompatible<Nothing>("class kinds are different (class, interface, object, enum, annotation)")
|
||||
|
||||
object ClassModifiers : WeakIncompatible<Nothing>("modifiers are different (companion, inner, inline, value)")
|
||||
|
||||
object FunInterfaceModifier : WeakIncompatible<Nothing>("actual declaration for fun expect interface is not a functional interface")
|
||||
|
||||
object Supertypes : WeakIncompatible<Nothing>("some supertypes are missing in the actual declaration")
|
||||
|
||||
class ClassScopes<D>(
|
||||
val unfulfilled: List<Pair<D, Map<Incompatible<D>, Collection<D>>>>
|
||||
) : WeakIncompatible<D>("some expected members have no actual ones")
|
||||
|
||||
object EnumEntries : WeakIncompatible<Nothing>("some entries from expected enum are missing in the actual enum")
|
||||
|
||||
// Common
|
||||
|
||||
object Modality : WeakIncompatible<Nothing>("modality is different")
|
||||
object Visibility : WeakIncompatible<Nothing>("visibility is different")
|
||||
|
||||
// FunctionTypeParameterUpperBounds is weak because functions can be overloaded by type parameter upper bounds
|
||||
object FunctionTypeParameterUpperBounds : StrongIncompatible<Nothing>("upper bounds of type parameters are different")
|
||||
|
||||
// ClassTypeParameterUpperBounds is strong because classes cannot be overloaded
|
||||
object ClassTypeParameterUpperBounds : WeakIncompatible<Nothing>(FunctionTypeParameterUpperBounds.reason)
|
||||
|
||||
object TypeParameterVariance : WeakIncompatible<Nothing>("declaration-site variances of type parameters are different")
|
||||
object TypeParameterReified : WeakIncompatible<Nothing>(
|
||||
"some type parameter is reified in one declaration and non-reified in the other"
|
||||
)
|
||||
}
|
||||
|
||||
object Compatible : ExpectActualCompatibility<Nothing>()
|
||||
}
|
||||
|
||||
val ExpectActualCompatibility<*>.isCompatibleOrWeaklyIncompatible: Boolean
|
||||
get() = this is ExpectActualCompatibility.Compatible
|
||||
|| this is ExpectActualCompatibility.Incompatible.WeakIncompatible
|
||||
|
||||
val ExpectActualCompatibility<*>.compatible: Boolean
|
||||
get() = this == ExpectActualCompatibility.Compatible
|
||||
|
||||
@OptIn(ExperimentalContracts::class)
|
||||
fun ExpectActualCompatibility<*>.isIncompatible(): Boolean {
|
||||
contract {
|
||||
returns(true) implies (this@isIncompatible is ExpectActualCompatibility.Incompatible<*>)
|
||||
}
|
||||
return !compatible
|
||||
}
|
||||
+219
@@ -0,0 +1,219 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* 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
|
||||
|
||||
import org.jetbrains.kotlin.descriptors.ClassKind
|
||||
import org.jetbrains.kotlin.descriptors.Modality
|
||||
import org.jetbrains.kotlin.descriptors.Visibility
|
||||
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<T : DeclarationSymbolMarker> : TypeSystemContext {
|
||||
val shouldCheckReturnTypesOfCallables: Boolean
|
||||
|
||||
/*
|
||||
* This flag indicates how are type parameters of inner classes stored in the specific implementation of RegularClassSymbolMarker
|
||||
*
|
||||
* class Outer<T> {
|
||||
* inner class Inner<U>
|
||||
* }
|
||||
*
|
||||
* If flag is set to `true` then `typeParameters` for class `Outer.Inner` contains both parameters: [U, R]
|
||||
* Otherwise it contains only parameters of itself: [U]
|
||||
*
|
||||
* This flag is needed for proper calculation of substitutions for components of inner classes
|
||||
*/
|
||||
val innerClassesCapturesOuterTypeParameters: Boolean
|
||||
get() = true
|
||||
|
||||
val enumConstructorsAreAlwaysCompatible: Boolean
|
||||
get() = false
|
||||
|
||||
// Try to drop it once KT-61105 is fixed
|
||||
val shouldCheckAbsenceOfDefaultParamsInActual: Boolean
|
||||
|
||||
/**
|
||||
* This flag determines, how visibilities for classes/typealiases will be matched
|
||||
* - `false` means that visibilities should be identical
|
||||
* - `true` means that visibility of actual class should be the same or wider comparing to expect visibility
|
||||
* this means that following actualizations will be additionally allowed:
|
||||
* - protected -> public
|
||||
* - internal -> public
|
||||
*/
|
||||
val allowClassActualizationWithWiderVisibility: Boolean
|
||||
get() = false
|
||||
|
||||
/**
|
||||
* This flag determines strategy for matching supertypes between expect and actual class
|
||||
* - `false` means that expect and actual supertypes are matched one by one
|
||||
* - `true` means that type of actual class should be subtype of each expect supertype of the expect class
|
||||
*/
|
||||
val allowTransitiveSupertypesActualization: Boolean
|
||||
get() = false
|
||||
|
||||
val RegularClassSymbolMarker.classId: ClassId
|
||||
val TypeAliasSymbolMarker.classId: ClassId
|
||||
val CallableSymbolMarker.callableId: CallableId
|
||||
val TypeParameterSymbolMarker.parameterName: Name
|
||||
val ValueParameterSymbolMarker.parameterName: Name
|
||||
|
||||
fun TypeAliasSymbolMarker.expandToRegularClass(): RegularClassSymbolMarker?
|
||||
|
||||
val RegularClassSymbolMarker.classKind: ClassKind
|
||||
|
||||
val RegularClassSymbolMarker.isCompanion: Boolean
|
||||
val RegularClassSymbolMarker.isInner: Boolean
|
||||
val RegularClassSymbolMarker.isInline: Boolean
|
||||
val RegularClassSymbolMarker.isValue: Boolean
|
||||
val RegularClassSymbolMarker.isFun: Boolean
|
||||
val ClassLikeSymbolMarker.typeParameters: List<TypeParameterSymbolMarker>
|
||||
|
||||
val ClassLikeSymbolMarker.modality: Modality?
|
||||
val ClassLikeSymbolMarker.visibility: Visibility
|
||||
|
||||
val CallableSymbolMarker.modality: Modality?
|
||||
val CallableSymbolMarker.visibility: Visibility
|
||||
|
||||
val RegularClassSymbolMarker.superTypes: List<KotlinTypeMarker>
|
||||
val RegularClassSymbolMarker.defaultType: KotlinTypeMarker
|
||||
|
||||
val CallableSymbolMarker.isExpect: Boolean
|
||||
val CallableSymbolMarker.isInline: Boolean
|
||||
val CallableSymbolMarker.isSuspend: Boolean
|
||||
val CallableSymbolMarker.isExternal: Boolean
|
||||
val CallableSymbolMarker.isInfix: Boolean
|
||||
val CallableSymbolMarker.isOperator: Boolean
|
||||
val CallableSymbolMarker.isTailrec: Boolean
|
||||
|
||||
val PropertySymbolMarker.isVar: Boolean
|
||||
val PropertySymbolMarker.isLateinit: Boolean
|
||||
val PropertySymbolMarker.isConst: Boolean
|
||||
|
||||
val PropertySymbolMarker.getter: FunctionSymbolMarker?
|
||||
val PropertySymbolMarker.setter: FunctionSymbolMarker?
|
||||
|
||||
fun createExpectActualTypeParameterSubstitutor(
|
||||
expectTypeParameters: List<TypeParameterSymbolMarker>,
|
||||
actualTypeParameters: List<TypeParameterSymbolMarker>,
|
||||
parentSubstitutor: TypeSubstitutorMarker?
|
||||
): TypeSubstitutorMarker
|
||||
|
||||
fun RegularClassSymbolMarker.collectAllMembers(isActualDeclaration: Boolean): List<DeclarationSymbolMarker>
|
||||
fun RegularClassSymbolMarker.getMembersForExpectClass(name: Name): List<DeclarationSymbolMarker>
|
||||
|
||||
fun RegularClassSymbolMarker.collectEnumEntryNames(): List<Name>
|
||||
fun RegularClassSymbolMarker.collectEnumEntries(): List<DeclarationSymbolMarker>
|
||||
|
||||
val CallableSymbolMarker.dispatchReceiverType: KotlinTypeMarker?
|
||||
val CallableSymbolMarker.extensionReceiverType: KotlinTypeMarker?
|
||||
val CallableSymbolMarker.returnType: KotlinTypeMarker
|
||||
val CallableSymbolMarker.typeParameters: List<TypeParameterSymbolMarker>
|
||||
val FunctionSymbolMarker.valueParameters: List<ValueParameterSymbolMarker>
|
||||
|
||||
/**
|
||||
* Returns all symbols that are overridden by [this] symbol
|
||||
*/
|
||||
fun FunctionSymbolMarker.allOverriddenDeclarationsRecursive(): Sequence<CallableSymbolMarker>
|
||||
|
||||
val CallableSymbolMarker.valueParameters: List<ValueParameterSymbolMarker>
|
||||
get() = (this as? FunctionSymbolMarker)?.valueParameters ?: emptyList()
|
||||
|
||||
val ValueParameterSymbolMarker.isVararg: Boolean
|
||||
val ValueParameterSymbolMarker.isNoinline: Boolean
|
||||
val ValueParameterSymbolMarker.isCrossinline: Boolean
|
||||
val ValueParameterSymbolMarker.hasDefaultValue: Boolean
|
||||
|
||||
fun CallableSymbolMarker.isAnnotationConstructor(): Boolean
|
||||
|
||||
val TypeParameterSymbolMarker.bounds: List<KotlinTypeMarker>
|
||||
val TypeParameterSymbolMarker.variance: Variance
|
||||
val TypeParameterSymbolMarker.isReified: Boolean
|
||||
|
||||
fun areCompatibleExpectActualTypes(
|
||||
expectType: KotlinTypeMarker?,
|
||||
actualType: KotlinTypeMarker?,
|
||||
): Boolean
|
||||
|
||||
fun actualTypeIsSubtypeOfExpectType(
|
||||
expectType: KotlinTypeMarker,
|
||||
actualType: KotlinTypeMarker
|
||||
): Boolean
|
||||
|
||||
fun RegularClassSymbolMarker.isNotSamInterface(): Boolean
|
||||
|
||||
/*
|
||||
* Determines should some declaration from expect class scope be checked
|
||||
* - FE 1.0: skip fake overrides
|
||||
* - FIR: skip fake overrides
|
||||
* - IR: skip nothing
|
||||
*/
|
||||
fun CallableSymbolMarker.shouldSkipMatching(containingExpectClass: RegularClassSymbolMarker): Boolean
|
||||
|
||||
val CallableSymbolMarker.hasStableParameterNames: Boolean
|
||||
|
||||
fun onMatchedMembers(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbol: DeclarationSymbolMarker,
|
||||
containingExpectClassSymbol: RegularClassSymbolMarker?,
|
||||
containingActualClassSymbol: RegularClassSymbolMarker?,
|
||||
) {}
|
||||
|
||||
fun onMismatchedMembersFromClassScope(
|
||||
expectSymbol: DeclarationSymbolMarker,
|
||||
actualSymbolsByIncompatibility: Map<ExpectActualCompatibility.Incompatible<*>, List<DeclarationSymbolMarker>>,
|
||||
containingExpectClassSymbol: RegularClassSymbolMarker?,
|
||||
containingActualClassSymbol: RegularClassSymbolMarker?,
|
||||
) {}
|
||||
|
||||
val DeclarationSymbolMarker.annotations: List<AnnotationCallInfo>
|
||||
|
||||
fun areAnnotationArgumentsEqual(
|
||||
expectAnnotation: AnnotationCallInfo,
|
||||
actualAnnotation: AnnotationCallInfo,
|
||||
collectionArgumentsCompatibilityCheckStrategy: ExpectActualCollectionArgumentsCompatibilityCheckStrategy,
|
||||
): Boolean
|
||||
|
||||
val DeclarationSymbolMarker.hasSourceAnnotationsErased: Boolean
|
||||
|
||||
interface AnnotationCallInfo {
|
||||
val annotationSymbol: Any
|
||||
val classId: ClassId?
|
||||
val isRetentionSource: Boolean
|
||||
val isOptIn: Boolean
|
||||
}
|
||||
|
||||
val checkClassScopesForAnnotationCompatibility: Boolean
|
||||
|
||||
/**
|
||||
* Determines whether it is needed to skip checking annotations on class member in [AbstractExpectActualAnnotationMatchChecker].
|
||||
*
|
||||
* This is needed to prevent checking member twice if it is real `actual` member (not fake override or member of
|
||||
* class being typealiased).
|
||||
* Example:
|
||||
* ```
|
||||
* actual class A {
|
||||
* actual fun foo() {} // 1: checked itself, 2: checked as member of A
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
fun skipCheckingAnnotationsOfActualClassMember(actualMember: DeclarationSymbolMarker): Boolean
|
||||
|
||||
fun findPotentialExpectClassMembersForActual(
|
||||
expectClass: RegularClassSymbolMarker,
|
||||
actualClass: RegularClassSymbolMarker,
|
||||
actualMember: DeclarationSymbolMarker,
|
||||
checkClassScopesCompatibility: Boolean,
|
||||
): Map<out DeclarationSymbolMarker, ExpectActualCompatibility<*>>
|
||||
|
||||
fun DeclarationSymbolMarker.getSourceElement(): SourceElementMarker
|
||||
}
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
|
||||
* 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.multiplatform
|
||||
|
||||
// This class will be later used by K2. That's why it's placed in compiler.common module
|
||||
data class ExpectActualMemberDiff<out M, out C>(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`
|
||||
*
|
||||
* Also see: [toMemberDiffKind]
|
||||
*/
|
||||
enum class Kind(val rawMessage: String) {
|
||||
NonPrivateCallableAdded(
|
||||
"{0}: non-private member must be declared in both the actual class and the expect class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
ReturnTypeChangedInOverride(
|
||||
"{0}: the return type of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
ModalityChangedInOverride(
|
||||
"{0}: the modality of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
VisibilityChangedInOverride(
|
||||
"{0}: the visibility of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
SetterVisibilityChangedInOverride(
|
||||
"{0}: the setter visibility of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
ParameterNameChangedInOverride(
|
||||
"{0}: the parameter names of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
PropertyKindChangedInOverride(
|
||||
"{0}: the property kind (val vs var) of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
LateinitChangedInOverride(
|
||||
"{0}: the property modifiers (lateinit) of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
TypeParameterNamesChangedInOverride(
|
||||
"{0}: the type parameter names of this member must be the same in the expect class and the actual class. " +
|
||||
"This error happens because the expect class ''{1}'' is non-final"
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
Reference in New Issue
Block a user