azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

K2: expand type aliases in annotation position #KT-55615 Fixed

Browse Source
This commit is contained in:
Mikhail Glukhikh
2022-12-22 12:53:32 +01:00
committed by Space Team
parent 3cf811012a
commit 0d50f71fb8
77 changed files with 345 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SupertypeWithArgumentGenerator.kt
+1 -1
View File
@@ -42,7 +42,7 @@ class SupertypeWithArgumentGenerator(session: FirSession) : FirSupertypeGenerati
): List<FirResolvedTypeRef> {
if (resolvedSupertypes.any { it.type.classId == supertypeClassId }) return emptyList()
val annotation = classLikeDeclaration.getAnnotationByClassId(annotationClassId) ?: return emptyList()
val annotation = classLikeDeclaration.getAnnotationByClassId(annotationClassId, session) ?: return emptyList()
val getClassArgument = (annotation as? FirAnnotationCall)?.argument as? FirGetClassCall ?: return emptyList()
val typeToResolve = buildUserTypeFromQualifierParts(isMarkedNullable = false) {
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/FirSerializableProperty.kt
+4 -4
View File
@@ -21,16 +21,16 @@ class FirSerializableProperty(
override val isConstructorParameterWithDefault: Boolean,
declaresDefaultValue: Boolean
) : ISerializableProperty {
override val name: String = propertySymbol.serialNameValue ?: propertySymbol.name.asString()
override val name: String = propertySymbol.getSerialNameValue(session) ?: propertySymbol.name.asString()
override val originalDescriptorName: Name
get() = propertySymbol.name
override val optional: Boolean = !propertySymbol.serialRequired && declaresDefaultValue
override val optional: Boolean = !propertySymbol.getSerialRequired(session) && declaresDefaultValue
override val transient: Boolean = propertySymbol.hasSerialTransient || !propertySymbol.hasBackingField
override val transient: Boolean = propertySymbol.hasSerialTransient(session) || !propertySymbol.hasBackingField
val serializableWith: ConeKotlinType? = propertySymbol.serializableWith
val serializableWith: ConeKotlinType? = propertySymbol.getSerializableWith(session)
?: analyzeSpecialSerializers(session, propertySymbol.resolvedAnnotationsWithArguments)?.defaultType()
}
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirSupertypesExtension.kt
+1 -1
View File
@@ -46,7 +46,7 @@ class SerializationFirSupertypesExtension(session: FirSession) : FirSupertypeGen
if (resolvedSupertypes.any { it.type.classId == kSerializerClassId || it.type.classId == generatedSerializerClassId }) return emptyList()
return if (session.predicateBasedProvider.matches(serializerFor, classLikeDeclaration)) {
val getClassArgument = classLikeDeclaration.serializerFor ?: return emptyList()
val getClassArgument = classLikeDeclaration.getSerializerFor(session) ?: return emptyList()
val serializerConeType = resolveConeTypeFromArgument(getClassArgument)
listOf(
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/SerializationFirUtils.kt
+37 -35
View File
@@ -39,43 +39,45 @@ object AnnotationParameterNames {
// ---------------------- annotations utils ----------------------
context(FirSession)
val FirBasedSymbol<*>.isSerialInfoAnnotation: Boolean
get() = hasAnnotation(serialInfoClassId)
|| hasAnnotation(inheritableSerialInfoClassId)
|| hasAnnotation(metaSerializableAnnotationClassId)
get() = hasAnnotation(serialInfoClassId, this@FirSession)
|| hasAnnotation(inheritableSerialInfoClassId, this@FirSession)
|| hasAnnotation(metaSerializableAnnotationClassId, this@FirSession)
val FirBasedSymbol<*>.isInheritableSerialInfoAnnotation: Boolean
get() = hasAnnotation(inheritableSerialInfoClassId)
fun FirBasedSymbol<*>.isInheritableSerialInfoAnnotation(session: FirSession): Boolean =
hasAnnotation(inheritableSerialInfoClassId, session)
val FirBasedSymbol<*>.serialNameAnnotation: FirAnnotation?
get() = resolvedAnnotationsWithArguments.getAnnotationByClassId(serialNameAnnotationClassId)
fun FirBasedSymbol<*>.getSerialNameAnnotation(session: FirSession): FirAnnotation? =
resolvedAnnotationsWithArguments.getAnnotationByClassId(serialNameAnnotationClassId, session)
val FirBasedSymbol<*>.serialNameValue: String?
get() = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE)
fun FirBasedSymbol<*>.getSerialNameValue(session: FirSession): String? =
getSerialNameAnnotation(session)?.getStringArgument(AnnotationParameterNames.VALUE)
val FirBasedSymbol<*>.serialRequired: Boolean
get() = hasAnnotation(SerializationAnnotations.requiredAnnotationClassId)
fun FirBasedSymbol<*>.getSerialRequired(session: FirSession): Boolean =
hasAnnotation(SerializationAnnotations.requiredAnnotationClassId, session)
val FirBasedSymbol<*>.hasSerialTransient: Boolean
get() = serialTransientAnnotation != null
fun FirBasedSymbol<*>.hasSerialTransient(session: FirSession): Boolean = getSerialTransientAnnotation(session) != null
val FirBasedSymbol<*>.serialTransientAnnotation: FirAnnotation?
get() = getAnnotationByClassId(SerializationAnnotations.serialTransientClassId)
fun FirBasedSymbol<*>.getSerialTransientAnnotation(session: FirSession): FirAnnotation? =
getAnnotationByClassId(SerializationAnnotations.serialTransientClassId, session)
context(FirSession)
@Suppress("IncorrectFormatting") // KTIJ-22227
val FirClassSymbol<*>.hasSerializableAnnotation: Boolean
get() = serializableAnnotation(needArguments = false) != null
get() = serializableAnnotation(needArguments = false, this@FirSession) != null
fun FirBasedSymbol<*>.serializableAnnotation(needArguments: Boolean): FirAnnotation? {
fun FirBasedSymbol<*>.serializableAnnotation(needArguments: Boolean, session: FirSession): FirAnnotation? {
val annotations = if (needArguments) resolvedAnnotationsWithClassIds else resolvedAnnotationsWithArguments
return annotations.serializableAnnotation()
return annotations.serializableAnnotation(session)
}
fun List<FirAnnotation>.serializableAnnotation(): FirAnnotation? {
return getAnnotationByClassId(SerializationAnnotations.serializableAnnotationClassId)
fun List<FirAnnotation>.serializableAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(SerializationAnnotations.serializableAnnotationClassId, session)
}
val FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs: Boolean
get() = serializableAnnotation(needArguments = false)?.let {
fun FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs(session: FirSession): Boolean =
serializableAnnotation(needArguments = false, session)?.let {
if (it is FirAnnotationCall) {
it.arguments.isEmpty()
} else {
@@ -83,27 +85,26 @@ val FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs: Boolean
}
} ?: false
internal val FirBasedSymbol<*>.serializableWith: ConeKotlinType?
get() = serializableAnnotation(needArguments = true)?.getKClassArgument(AnnotationParameterNames.WITH)
internal fun FirBasedSymbol<*>.getSerializableWith(session: FirSession): ConeKotlinType? =
serializableAnnotation(needArguments = true, session)?.getKClassArgument(AnnotationParameterNames.WITH)
internal val List<FirAnnotation>.serializableWith: ConeKotlinType?
get() = serializableAnnotation()?.getKClassArgument(AnnotationParameterNames.WITH)
internal fun List<FirAnnotation>.getSerializableWith(session: FirSession): ConeKotlinType? =
serializableAnnotation(session)?.getKClassArgument(AnnotationParameterNames.WITH)
fun FirAnnotation.getGetKClassArgument(name: Name): FirGetClassCall? {
return findArgumentByName(name) as? FirGetClassCall
}
internal val FirClassSymbol<*>.serializerAnnotation: FirAnnotation?
get() = getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId)
internal fun FirClassSymbol<*>.getSerializerAnnotation(session: FirSession): FirAnnotation? =
getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session)
// ---------------------- class utils ----------------------
internal val FirClassSymbol<*>.serializerForClass: ConeKotlinType?
get() = resolvedAnnotationsWithArguments
.getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId)
?.getKClassArgument(AnnotationParameterNames.FOR_CLASS)
internal fun FirClassSymbol<*>.getSerializerForClass(session: FirSession): ConeKotlinType? = resolvedAnnotationsWithArguments
.getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session)
?.getKClassArgument(AnnotationParameterNames.FOR_CLASS)
internal val FirClassLikeDeclaration.serializerFor: FirGetClassCall?
get() = getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId)
internal fun FirClassLikeDeclaration.getSerializerFor(session: FirSession): FirGetClassCall? =
getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session)
?.getGetKClassArgument(AnnotationParameterNames.FOR_CLASS)
context(FirSession)
@@ -147,7 +148,8 @@ internal val FirClassSymbol<*>.isInternalSerializable: Boolean
context(FirSession)
val FirClassSymbol<*>.hasSerializableOrMetaAnnotationWithoutArgs: Boolean
get() = hasSerializableAnnotationWithoutArgs || (!hasSerializableAnnotation && hasMetaSerializableAnnotation)
get() = hasSerializableAnnotationWithoutArgs(this@FirSession) ||
(!hasSerializableAnnotation && hasMetaSerializableAnnotation)
context(FirSession)
@Suppress("IncorrectFormatting") // KTIJ-22227
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/FirSerializationPluginClassChecker.kt
+15 -17
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.KtSourceElement
import org.jetbrains.kotlin.config.KotlinCompilerVersion
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.diagnostics.*
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker
import org.jetbrains.kotlin.fir.analysis.checkers.isSingleFieldValueClass
@@ -20,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.moduleData
import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.*
@@ -28,7 +26,7 @@ import org.jetbrains.kotlin.resolve.jvm.annotations.TRANSIENT_ANNOTATION_CLASS_I
import org.jetbrains.kotlin.types.AbstractTypeChecker
import org.jetbrains.kotlinx.serialization.compiler.diagnostic.RuntimeVersions
import org.jetbrains.kotlinx.serialization.compiler.fir.*
import org.jetbrains.kotlinx.serialization.compiler.fir.serializerForClass
import org.jetbrains.kotlinx.serialization.compiler.fir.getSerializerForClass
import org.jetbrains.kotlinx.serialization.compiler.fir.services.dependencySerializationInfoProvider
import org.jetbrains.kotlinx.serialization.compiler.fir.services.findTypeSerializerOrContextUnchecked
import org.jetbrains.kotlinx.serialization.compiler.fir.services.serializablePropertiesProvider
@@ -73,11 +71,11 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
private fun checkExternalSerializer(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) {
val serializableKType = classSymbol.serializerForClass ?: return
val serializableKType = classSymbol.getSerializerForClass(session) ?: return
val serializableClassSymbol = serializableKType.toRegularClassSymbol(session) ?: return
val properties = session.serializablePropertiesProvider.getSerializablePropertiesForClass(serializableClassSymbol)
if (!properties.isExternallySerializable) {
val source = classSymbol.serializerAnnotation?.source ?: classSymbol.source
val source = classSymbol.getSerializerAnnotation(session)?.source ?: classSymbol.source
val error = if (serializableClassSymbol.moduleData == session.moduleData) {
FirSerializationErrors.EXTERNAL_CLASS_NOT_SERIALIZABLE
} else {
@@ -93,7 +91,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
private fun checkInheritedAnnotations(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) {
fun annotationsFilter(annotations: List<FirAnnotation>): List<Pair<ClassId, FirAnnotation>> {
return annotations
.filter { it.annotationTypeRef.toRegularClassSymbol(session)?.isInheritableSerialInfoAnnotation == true }
.filter { it.annotationTypeRef.toRegularClassSymbol(session)?.isInheritableSerialInfoAnnotation(session) == true }
.mapNotNull { annotation -> annotation.classId?.let { it to annotation } }
}
@@ -196,7 +194,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
if (classSymbol.resolvedSuperTypes.any { it.classId == JAVA_SERIALIZABLE_ID }) return // do not check
for (property in properties) {
if (property.transient) continue
val incorrectTransient = property.propertySymbol.annotations.getAnnotationByClassId(TRANSIENT_ANNOTATION_CLASS_ID)
val incorrectTransient = property.propertySymbol.annotations.getAnnotationByClassId(TRANSIENT_ANNOTATION_CLASS_ID, session)
if (incorrectTransient != null) {
reporter.reportOn(
source = incorrectTransient.source ?: property.propertySymbol.source,
@@ -277,8 +275,8 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
private fun checkCompanionSerializerDependency(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) = with(session) {
if (classSymbol !is FirRegularClassSymbol) return
val companionObjectSymbol = classSymbol.companionObjectSymbol ?: return
val serializerForInCompanion = companionObjectSymbol.serializerForClass?.toRegularClassSymbol(session) ?: return
val serializableWith: ConeKotlinType? = classSymbol.serializableWith
val serializerForInCompanion = companionObjectSymbol.getSerializerForClass(session)?.toRegularClassSymbol(session) ?: return
val serializableWith: ConeKotlinType? = classSymbol.getSerializableWith(session)
if (classSymbol.hasSerializableOrMetaAnnotationWithoutArgs) {
if (serializerForInCompanion.classId == classSymbol.classId) {
// @Serializable class Foo / @Serializer(Foo::class) companion object — prohibited due to problems with recursive resolve
@@ -289,7 +287,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
)
} else {
// @Serializable class Foo / @Serializer(Bar::class) companion object — prohibited as vague and confusing
val source = companionObjectSymbol.serializerAnnotation?.source
val source = companionObjectSymbol.getSerializerAnnotation(session)?.source
reporter.reportOn(
source,
FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS,
@@ -303,7 +301,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
} else {
// @Serializable(anySer) class Foo / @Serializer(anyOtherClass) companion object — prohibited as vague and confusing
reporter.reportOn(
companionObjectSymbol.serializerAnnotation?.source,
companionObjectSymbol.getSerializerAnnotation(session)?.source,
FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS,
classSymbol.defaultType(),
serializerForInCompanion.defaultType()
@@ -312,7 +310,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
} else {
// (regular) class Foo / @Serializer(something) companion object - not recommended
reporter.reportOn(
companionObjectSymbol.serializerAnnotation?.source,
companionObjectSymbol.getSerializerAnnotation(session)?.source,
FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_NON_SERIALIZABLE_CLASS,
classSymbol.defaultType(),
serializerForInCompanion.defaultType()
@@ -324,7 +322,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
private fun checkClassWithCustomSerializer(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) {
val serializerType = classSymbol.serializableWith?.fullyExpandedType(session) ?: return
val serializerType = classSymbol.getSerializableWith(session)?.fullyExpandedType(session) ?: return
checkCustomSerializerMatch(classSymbol, source = null, classSymbol.defaultType(), serializerType, reporter)
checkCustomSerializerIsNotLocal(source = null, classSymbol, serializerType, reporter)
}
@@ -343,12 +341,12 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
if (!classSymbol.isEnumClass) return
val entryBySerialName = mutableMapOf<String, FirEnumEntrySymbol>()
for (enumEntrySymbol in classSymbol.collectEnumEntries()) {
val serialNameAnnotation = enumEntrySymbol.serialNameAnnotation
val serialNameAnnotation = enumEntrySymbol.getSerialNameAnnotation(session)
val serialName = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE) ?: enumEntrySymbol.name.asString()
val firstEntry = entryBySerialName[serialName]
if (firstEntry != null) {
reporter.reportOn(
source = serialNameAnnotation?.source ?: firstEntry.serialNameAnnotation?.source ?: enumEntrySymbol.source,
source = serialNameAnnotation?.source ?: firstEntry.getSerialNameAnnotation(session)?.source ?: enumEntrySymbol.source,
FirSerializationErrors.DUPLICATE_SERIAL_NAME_ENUM,
classSymbol,
serialName,
@@ -394,7 +392,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
private fun checkTransients(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) {
for (propertySymbol in classSymbol.declarationSymbols.filterIsInstance<FirPropertySymbol>()) {
val isInitialized = propertySymbol.isLateInit || declarationHasInitializer(propertySymbol)
val transientAnnotation = propertySymbol.serialTransientAnnotation ?: continue
val transientAnnotation = propertySymbol.getSerialTransientAnnotation(session) ?: continue
val hasBackingField = propertySymbol.hasBackingField
if (!hasBackingField) {
reporter.reportOn(transientAnnotation.source ?: propertySymbol.source, FirSerializationErrors.TRANSIENT_IS_REDUNDANT)
@@ -441,7 +439,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
reporter
)
checkCustomSerializerIsNotLocal(
source = propertySymbol.serializableAnnotation(needArguments = false)?.source,
source = propertySymbol.serializableAnnotation(needArguments = false, session)?.source,
classSymbol,
customSerializerType,
reporter
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/checkers/SerializationFirCheckerUtils.kt
+9 -7
View File
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlinx.serialization.compiler.fir.*
import org.jetbrains.kotlinx.serialization.compiler.fir.serializableWith
import org.jetbrains.kotlinx.serialization.compiler.fir.getSerializableWith
import org.jetbrains.kotlinx.serialization.compiler.fir.services.dependencySerializationInfoProvider
import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations
@@ -46,7 +46,7 @@ internal val FirClassSymbol<*>?.classSerializer: FirClassSymbol<*>?
get() {
if (this == null) return null
// serializer annotation on class?
serializableWith?.let { return it.toRegularClassSymbol(session) }
getSerializableWith(session)?.let { return it.toRegularClassSymbol(session) }
// companion object serializer?
if (this is FirRegularClassSymbol && with(session) { isInternallySerializableObject }) return companionObjectSymbol
// can infer @Poly?
@@ -93,7 +93,7 @@ internal val FirAnnotation.annotationClassSymbol: FirRegularClassSymbol?
context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
internal val FirAnnotation.isMetaSerializableAnnotation: Boolean
get() = annotationClassSymbol?.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationClassId) ?: false
get() = annotationClassSymbol?.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationClassId, session) ?: false
context(CheckerContext)
@@ -107,7 +107,7 @@ context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceElement?
get() {
serializableAnnotation(needArguments = false)?.source?.let { return it }
serializableAnnotation(needArguments = false, session)?.source?.let { return it }
metaSerializableAnnotation(needArguments = false)?.source?.let { return it }
return null
}
@@ -115,7 +115,9 @@ internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceEleme
context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
internal val FirBasedSymbol<*>.hasAnySerialAnnotation: Boolean
get() = serialNameValue != null || resolvedAnnotationsWithClassIds.any { it.annotationClassSymbol?.isSerialInfoAnnotation == true }
get() = getSerialNameValue(session) != null || resolvedAnnotationsWithClassIds.any {
with(session) { it.annotationClassSymbol?.isSerialInfoAnnotation == true }
}
// ---------------------- class utils ----------------------
@@ -155,13 +157,13 @@ internal val FirClassSymbol<*>.serializableAnnotationIsUseless: Boolean
context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
internal val ConeKotlinType.serializableWith: ConeKotlinType?
get() = customAnnotations.serializableWith ?: toRegularClassSymbol(session)?.serializableWith
get() = customAnnotations.getSerializableWith(session) ?: toRegularClassSymbol(session)?.getSerializableWith(session)
context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227
internal val ConeKotlinType.overriddenSerializer: ConeKotlinType?
get() = toRegularClassSymbol(session)?.serializableWith
get() = toRegularClassSymbol(session)?.getSerializableWith(session)
// ---------------------- others ----------------------
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/ContextualSerializersProvider.kt
+7 -5
View File
@@ -63,7 +63,9 @@ class ContextualSerializersProvider(session: FirSession) : FirExtensionSessionCo
}
private fun getKClassListFromFileAnnotation(file: FirFile, annotationClassId: ClassId): List<ConeKotlinType> {
val annotation = file.symbol.resolvedAnnotationsWithArguments.getAnnotationByClassId(annotationClassId) ?: return emptyList()
val annotation = file.symbol.resolvedAnnotationsWithArguments.getAnnotationByClassId(
annotationClassId, session
) ?: return emptyList()
val arguments = when (val argument = annotation.argumentMapping.mapping.values.firstOrNull()) {
is FirArrayOfCall -> argument.arguments
is FirVarargArgumentsExpression -> argument.arguments
@@ -79,7 +81,7 @@ context(CheckerContext)
fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<*>? {
if (type.isTypeParameter) return null
val annotations = type.fullyExpandedType(session).customAnnotations
annotations.serializableWith?.let { return it.toRegularClassSymbol(session) }
annotations.getSerializableWith(session)?.let { return it.toRegularClassSymbol(session) }
val classSymbol = type.toRegularClassSymbol(session) ?: return null
val currentFile = currentFile
val provider = session.contextualSerializersProvider
@@ -98,12 +100,12 @@ fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<*
* if [annotations] contains @Contextual or @Polymorphic annotation
*/
fun analyzeSpecialSerializers(session: FirSession, annotations: List<FirAnnotation>): FirClassSymbol<*>? = when {
annotations.hasAnnotation(SerializationAnnotations.contextualClassId) ||
annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyClassId) -> {
annotations.hasAnnotation(SerializationAnnotations.contextualClassId, session) ||
annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyClassId, session) -> {
session.dependencySerializationInfoProvider.getClassFromSerializationPackage(SpecialBuiltins.Names.contextSerializer)
}
// can be annotation on type usage, e.g. List<@Polymorphic Any>
annotations.hasAnnotation(SerializationAnnotations.polymorphicClassId) -> {
annotations.hasAnnotation(SerializationAnnotations.polymorphicClassId, session) -> {
session.dependencySerializationInfoProvider.getClassFromSerializationPackage(SpecialBuiltins.Names.polymorphicSerializer)
}
plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/services/FirSerializablePropertiesProvider.kt
+2 -2
View File
@@ -57,9 +57,9 @@ class FirSerializablePropertiesProvider(session: FirSession) : FirExtensionSessi
fun isPropertySerializable(propertySymbol: FirPropertySymbol): Boolean {
return when {
isInternalSerializable -> !propertySymbol.hasSerialTransient
isInternalSerializable -> !propertySymbol.hasSerialTransient(session)
propertySymbol.visibility == Visibilities.Private -> false
else -> (propertySymbol.isVar && propertySymbol.hasSerialTransient) || propertySymbol in primaryConstructorProperties
else -> (propertySymbol.isVar && propertySymbol.hasSerialTransient(session)) || propertySymbol in primaryConstructorProperties
}
}
plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/diagnostics/FirParcelizePropertyChecker.kt
+6 -5
View File
@@ -33,15 +33,16 @@ import org.jetbrains.kotlin.parcelize.ParcelizeNames.PARCELER_ID
object FirParcelizePropertyChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
val containingClassSymbol = declaration.dispatchReceiverType?.toRegularClassSymbol(context.session) ?: return
val session = context.session
val containingClassSymbol = declaration.dispatchReceiverType?.toRegularClassSymbol(session) ?: return
if (containingClassSymbol.isParcelize(context.session)) {
if (containingClassSymbol.isParcelize(session)) {
val fromPrimaryConstructor = declaration.fromPrimaryConstructor ?: false
if (
!fromPrimaryConstructor &&
(declaration.hasBackingField || declaration.delegate != null) &&
!declaration.hasIgnoredOnParcel() &&
!containingClassSymbol.hasCustomParceler(context.session)
!containingClassSymbol.hasCustomParceler(session)
) {
reporter.reportOn(declaration.source, KtErrorsParcelize.PROPERTY_WONT_BE_SERIALIZED, context)
}
@@ -50,9 +51,9 @@ object FirParcelizePropertyChecker : FirPropertyChecker() {
}
}
if (declaration.name == CREATOR_NAME && containingClassSymbol.isCompanion && declaration.hasJvmFieldAnnotation) {
if (declaration.name == CREATOR_NAME && containingClassSymbol.isCompanion && declaration.hasJvmFieldAnnotation(session)) {
val outerClass = context.containingDeclarations.asReversed().getOrNull(1) as? FirRegularClass
if (outerClass != null && outerClass.symbol.isParcelize(context.session)) {
if (outerClass != null && outerClass.symbol.isParcelize(session)) {
reporter.reportOn(declaration.source, KtErrorsParcelize.CREATOR_DEFINITION_IS_NOT_ALLOWED, context)
}
}