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
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolInfoProvider.kt
+3 -3
View File
@@ -95,19 +95,19 @@ internal class KtFirSymbolInfoProvider(
}
private fun getJvmName(property: FirProperty, isSetter: Boolean): Name {
if (property.hasAnnotation(StandardClassIds.Annotations.JvmField)) return property.name
if (property.hasAnnotation(StandardClassIds.Annotations.JvmField, analysisSession.useSiteSession)) return property.name
return Name.identifier(getJvmNameAsString(property, isSetter))
}
private fun getJvmNameAsString(property: FirProperty, isSetter: Boolean): String {
val useSiteTarget = if (isSetter) AnnotationUseSiteTarget.PROPERTY_SETTER else AnnotationUseSiteTarget.PROPERTY_GETTER
val jvmNameFromProperty = property.getJvmNameFromAnnotation(useSiteTarget)
val jvmNameFromProperty = property.getJvmNameFromAnnotation(analysisSession.useSiteSession, useSiteTarget)
if (jvmNameFromProperty != null) {
return jvmNameFromProperty
}
val accessor = if (isSetter) property.setter else property.getter
val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation()
val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation(analysisSession.useSiteSession)
if (jvmNameFromAccessor != null) {
return jvmNameFromAccessor
}
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/FileStructureElementDiagnosticRetriever.kt
+1 -2
View File
@@ -60,11 +60,10 @@ internal class SingleNonLocalDeclarationDiagnosticRetriever(
return true
}
@Suppress("IntroduceWhenSubject")
return when {
structureElementDeclaration !is FirRegularClass -> true
structureElementDeclaration == declaration -> true
declaration.hasAnnotation(StandardClassIds.Annotations.Suppress) -> {
declaration.hasAnnotation(StandardClassIds.Annotations.Suppress, context.session) -> {
useRegularComponents = false
true
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt
+6 -2
View File
@@ -7,14 +7,18 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers
import org.jetbrains.kotlin.config.JvmDefaultMode
import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.name.StandardClassIds
fun <D> FirBasedSymbol<out D>.isCompiledToJvmDefault(jvmDefaultMode: JvmDefaultMode): Boolean where D : FirAnnotationContainer, D : FirDeclaration {
fun <D> FirBasedSymbol<out D>.isCompiledToJvmDefault(
session: FirSession,
jvmDefaultMode: JvmDefaultMode
): Boolean where D : FirAnnotationContainer, D : FirDeclaration {
// TODO: Fix support for all cases
if (getAnnotationByClassId(StandardClassIds.Annotations.JvmDefault) != null) return true
if (getAnnotationByClassId(StandardClassIds.Annotations.JvmDefault, session) != null) return true
return jvmDefaultMode.forAllMethodsWithBody
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt
+5 -10
View File
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.analysis.checkers.context.findClosest
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isCompiledToJvmDefault
import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6
import org.jetbrains.kotlin.fir.containingClassLookupTag
import org.jetbrains.kotlin.fir.declarations.*
@@ -33,7 +32,8 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_I
object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val jvmDefaultMode = context.session.jvmDefaultModeState
val defaultAnnotation = declaration.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID)
val session = context.session
val defaultAnnotation = declaration.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID, session)
if (defaultAnnotation != null) {
val containingDeclaration = context.findClosest<FirClassLikeDeclaration>()
@@ -53,7 +53,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
}
}
} else {
val annotationNoCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID)
val annotationNoCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID, session)
if (annotationNoCompatibility != null) {
val source = annotationNoCompatibility.source
when {
@@ -77,7 +77,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
}
}
}
val annotationWithCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_ID)
val annotationWithCompatibility = declaration.getAnnotationByClassId(JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_ID, session)
if (annotationWithCompatibility != null) {
val source = annotationWithCompatibility.source
when {
@@ -121,7 +121,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
unsubstitutedScope.processFunctionsByName(member.name) {}
val overriddenFunctions = unsubstitutedScope.getDirectOverriddenFunctions(member.symbol)
if (overriddenFunctions.any { it.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID) != null }) {
if (overriddenFunctions.any { it.getAnnotationByClassId(JVM_DEFAULT_CLASS_ID, context.session) != null }) {
reporter.reportOn(declaration.source, FirJvmErrors.JVM_DEFAULT_REQUIRED_FOR_OVERRIDE, context)
} else if (jvmDefaultMode.isEnabled) {
for (overriddenFunction in overriddenFunctions) {
@@ -147,9 +147,4 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
ArrayList<FirCallableSymbol<*>>(1).also { it.add(this) }
}
}
fun FirCallableSymbol<*>.isCompiledToJvmDefaultWithProperMode(jvmDefaultMode: JvmDefaultMode): Boolean {
// TODO: Fix support for all cases
return isCompiledToJvmDefault(jvmDefaultMode)
}
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt
+6 -6
View File
@@ -40,8 +40,8 @@ import org.jetbrains.kotlin.name.StandardClassIds
object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) ?: return
val session = context.session
val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID, session) ?: return
val containingClassSymbol = declaration.containingClassLookupTag()?.toFirRegularClassSymbol(session)
val problem = when {
@@ -57,7 +57,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
if (!session.languageVersionSettings.supportsFeature(LanguageFeature.JvmFieldInInterface)) {
INSIDE_COMPANION_OF_INTERFACE
} else {
if (!isInterfaceCompanionWithPublicJvmFieldProperties(containingClassSymbol)) {
if (!isInterfaceCompanionWithPublicJvmFieldProperties(containingClassSymbol, session)) {
NOT_PUBLIC_VAL_WITH_JVMFIELD
} else {
return
@@ -110,7 +110,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
return outerClassKind == ClassKind.INTERFACE || outerClassKind == ClassKind.ANNOTATION_CLASS
}
private fun isInterfaceCompanionWithPublicJvmFieldProperties(containingClass: FirRegularClassSymbol): Boolean {
private fun isInterfaceCompanionWithPublicJvmFieldProperties(containingClass: FirRegularClassSymbol, session: FirSession): Boolean {
for (symbol in containingClass.declarationSymbols) {
if (symbol !is FirPropertySymbol) continue
@@ -118,7 +118,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
return false
}
if (!symbol.hasJvmFieldAnnotation()) {
if (!symbol.hasJvmFieldAnnotation(session)) {
return false
}
}
@@ -126,8 +126,8 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
return true
}
private fun FirPropertySymbol.hasJvmFieldAnnotation(): Boolean {
return getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) != null
private fun FirPropertySymbol.hasJvmFieldAnnotation(session: FirSession): Boolean {
return getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID, session) != null
}
private fun isInsideJvmMultifileClassFile(context: CheckerContext): Boolean {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmInlineApplicabilityChecker.kt
+1 -1
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.resolve.JVM_INLINE_ANNOTATION_CLASS_ID
object FirJvmInlineApplicabilityChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.getAnnotationByClassId(JVM_INLINE_ANNOTATION_CLASS_ID)
val annotation = declaration.getAnnotationByClassId(JVM_INLINE_ANNOTATION_CLASS_ID, context.session)
if (annotation != null && !declaration.isInline) {
reporter.reportOn(annotation.source, FirJvmErrors.JVM_INLINE_WITHOUT_VALUE_CLASS, context)
} else if (annotation == null && declaration.isInline && !declaration.isExpect) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRecordChecker.kt
+1 -2
View File
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.classId
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.JvmNames.JVM_RECORD_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.StandardClassIds
@@ -37,7 +36,7 @@ object FirJvmRecordChecker : FirRegularClassChecker() {
}
}
val annotationSource = declaration.getAnnotationByClassId(JVM_RECORD_ANNOTATION_CLASS_ID)?.source ?: return
val annotationSource = declaration.getAnnotationByClassId(JVM_RECORD_ANNOTATION_CLASS_ID, context.session)?.source ?: return
val languageVersionSettings = context.session.languageVersionSettings
if (!languageVersionSettings.supportsFeature(LanguageFeature.JvmRecordSupport)) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt
+1 -1
View File
@@ -48,7 +48,7 @@ object FirJvmStaticChecker : FirBasicDeclarationChecker() {
}
fun checkIfAnnotated(it: FirDeclaration) {
if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic)) {
if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic, context.session)) {
return
}
val targetSource = it.source ?: declaration.source
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmSyntheticApplicabilityChecker.kt
+1 -1
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_SYNTHETIC_ANNOTATION_CLASS_ID
object FirJvmSyntheticApplicabilityChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(JVM_SYNTHETIC_ANNOTATION_CLASS_ID)
val annotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(JVM_SYNTHETIC_ANNOTATION_CLASS_ID, context.session)
if (annotation != null && annotation.useSiteTarget == AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD) {
reporter.reportOn(annotation.source, FirJvmErrors.JVM_SYNTHETIC_ON_DELEGATE, context)
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt
+3 -2
View File
@@ -27,11 +27,12 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_OVERLOADS_CLASS_ID
object FirOverloadsChecker : FirFunctionChecker() {
override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.getAnnotationByClassId(JVM_OVERLOADS_CLASS_ID) ?: return
val session = context.session
val annotation = declaration.getAnnotationByClassId(JVM_OVERLOADS_CLASS_ID, session) ?: return
//todo need to have expect declaration here to check if it has default values
if (declaration.isActual) return
val containingDeclaration = declaration.getContainingClassSymbol(context.session)
val containingDeclaration = declaration.getContainingClassSymbol(session)
when {
containingDeclaration?.classKind == ClassKind.INTERFACE ->
reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_INTERFACE, context)
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt
+11 -11
View File
@@ -11,13 +11,13 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.containsRepeatableAnnotation
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationRetention
import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6
import org.jetbrains.kotlin.fir.declarations.*
@@ -48,7 +48,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
val session = context.session
for (annotation in annotations) {
val classId = annotation.classId ?: continue
val annotationClassId = annotation.toAnnotationClassId() ?: continue
val annotationClassId = annotation.toAnnotationClassId(session) ?: continue
if (annotationClassId.isLocal) continue
val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: continue
@@ -60,7 +60,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
if (duplicateAnnotation &&
annotationClass.containsRepeatableAnnotation(session) &&
annotationClass.getAnnotationRetention() != AnnotationRetention.SOURCE
annotationClass.getAnnotationRetention(session) != AnnotationRetention.SOURCE
) {
if (context.isJvm6()) {
reporter.reportOn(annotation.source, FirJvmErrors.REPEATED_ANNOTATION_TARGET6, context)
@@ -68,7 +68,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
// It's not allowed to have both a repeated annotation (applied more than once) and its container
// on the same element.
// See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.7.5.
val explicitContainer = annotationClass.resolveContainerAnnotation()
val explicitContainer = annotationClass.resolveContainerAnnotation(session)
if (explicitContainer != null && annotations.any { it.classId == explicitContainer }) {
reporter.reportOn(
annotation.source,
@@ -99,9 +99,9 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
}
}
private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(): ClassId? {
val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable)
?: getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable)
private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(session: FirSession): ClassId? {
val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session)
?: getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable, session)
?: return null
return repeatableAnnotation.resolveContainerAnnotation()
}
@@ -202,8 +202,8 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
context: CheckerContext,
reporter: DiagnosticReporter
) {
val annotationRetention = annotationClass.symbol.getAnnotationRetention()
val containerRetention = containerClass.getAnnotationRetention()
val annotationRetention = annotationClass.symbol.getAnnotationRetention(context.session)
val containerRetention = containerClass.getAnnotationRetention(context.session)
if (containerRetention < annotationRetention) {
reporter.reportOn(
annotationSource,
@@ -224,8 +224,8 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
context: CheckerContext,
reporter: DiagnosticReporter
) {
val annotationTargets = annotationClass.getAllowedAnnotationTargets()
val containerTargets = containerClass.getAllowedAnnotationTargets()
val annotationTargets = annotationClass.getAllowedAnnotationTargets(context.session)
val containerTargets = containerClass.getAllowedAnnotationTargets(context.session)
// See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.6.3.
// (TBH, the rules about TYPE/TYPE_USE and TYPE_PARAMETER/TYPE_USE don't seem to make a lot of sense, but it's JLS
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirStrictfpApplicabilityChecker.kt
+1 -1
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID
object FirStrictfpApplicabilityChecker : FirClassChecker() {
override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.getAnnotationByClassId(STRICTFP_ANNOTATION_CLASS_ID) ?: return
val annotation = declaration.getAnnotationByClassId(STRICTFP_ANNOTATION_CLASS_ID, context.session) ?: return
reporter.reportOn(annotation.source, FirJvmErrors.STRICTFP_ON_CLASS, context)
}
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirSynchronizedAnnotationChecker.kt
+4 -4
View File
@@ -5,7 +5,6 @@
package org.jetbrains.kotlin.fir.analysis.jvm.checkers.declaration
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.fir.analysis.checkers.classKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -26,20 +25,21 @@ import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID
object FirSynchronizedAnnotationChecker : FirFunctionChecker() {
override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.getAnnotationByClassId(SYNCHRONIZED_ANNOTATION_CLASS_ID) ?: return
val session = context.session
val annotation = declaration.getAnnotationByClassId(SYNCHRONIZED_ANNOTATION_CLASS_ID, session) ?: return
if (declaration.isInline) {
reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_INLINE, context)
return
}
if (declaration.isSuspend ||
(declaration as? FirAnonymousFunction)?.typeRef?.coneType?.isSuspendFunctionType(context.session) == true
(declaration as? FirAnonymousFunction)?.typeRef?.coneType?.isSuspendFunctionType(session) == true
) {
reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_SUSPEND, context)
return
}
val containingClass = declaration.getContainingClassSymbol(context.session) ?: return
val containingClass = declaration.getContainingClassSymbol(session) ?: return
if (containingClass.classKind == ClassKind.INTERFACE) {
reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_IN_INTERFACE, context)
} else if (declaration.isAbstract) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirVolatileAnnotationChecker.kt
+2 -2
View File
@@ -19,12 +19,12 @@ object FirVolatileAnnotationChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration.source?.kind != KtRealSourceElementKind) return
val fieldAnnotation = declaration.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID)
val fieldAnnotation = declaration.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID, context.session)
if (fieldAnnotation != null && !declaration.isVar) {
reporter.reportOn(fieldAnnotation.source, FirJvmErrors.VOLATILE_ON_VALUE, context)
}
val delegateAnnotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID)
val delegateAnnotation = declaration.delegateFieldSymbol?.getAnnotationByClassId(VOLATILE_ANNOTATION_CLASS_ID, context.session)
if (delegateAnnotation != null) {
reporter.reportOn(delegateAnnotation.source, FirJvmErrors.VOLATILE_ON_DELEGATE, context)
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirInterfaceDefaultMethodCallChecker.kt
+7 -4
View File
@@ -30,8 +30,9 @@ object FirInterfaceDefaultMethodCallChecker : FirQualifiedAccessExpressionChecke
val classId = symbol?.callableId?.classId ?: return
if (classId.isLocal) return
val session = context.session
fun getTypeSymbol(): FirRegularClassSymbol? {
return context.session.symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol
return session.symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol
}
val supportsDefaults = !context.isJvm6()
@@ -49,11 +50,13 @@ object FirInterfaceDefaultMethodCallChecker : FirQualifiedAccessExpressionChecke
if (typeSymbol == null) typeSymbol = getTypeSymbol() ?: return
val jvmDefaultMode = context.session.jvmDefaultModeState
if (typeSymbol.isInterface && (typeSymbol.origin is FirDeclarationOrigin.Java || symbol.isCompiledToJvmDefault(jvmDefaultMode))) {
val jvmDefaultMode = session.jvmDefaultModeState
if (typeSymbol.isInterface &&
(typeSymbol.origin is FirDeclarationOrigin.Java || symbol.isCompiledToJvmDefault(session, jvmDefaultMode))
) {
if (containingDeclaration.isInterface) {
val containingMember = context.findContainingMember()?.symbol
if (containingMember?.isCompiledToJvmDefault(jvmDefaultMode) == false) {
if (containingMember?.isCompiledToJvmDefault(session, jvmDefaultMode) == false) {
reporter.reportOn(expression.source, FirJvmErrors.INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER, context)
return
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmPolymorphicSignatureCallChecker.kt
+1 -1
View File
@@ -23,7 +23,7 @@ object FirJvmPolymorphicSignatureCallChecker : FirFunctionCallChecker() {
override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
if (!context.session.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature)) return
val callableSymbol = expression.calleeReference.toResolvedCallableSymbol() ?: return
if (callableSymbol.getAnnotationByClassId(polymorphicSignatureClassId) == null) return
if (callableSymbol.getAnnotationByClassId(polymorphicSignatureClassId, context.session) == null) return
for (valueArgument in expression.arguments) {
if (valueArgument is FirVarargArgumentsExpression) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJvmProtectedInSuperClassCompanionCallChecker.kt
+1 -1
View File
@@ -45,7 +45,7 @@ object FirJvmProtectedInSuperClassCompanionCallChecker : FirQualifiedAccessCheck
resolvedSymbol.visibility
}
if (visibility != Visibilities.Protected) return
if (resolvedSymbol.getAnnotationByClassId(JVM_STATIC_ANNOTATION_CLASS_ID) != null) return
if (resolvedSymbol.getAnnotationByClassId(JVM_STATIC_ANNOTATION_CLASS_ID, context.session) != null) return
if (!dispatchClassSymbol.isCompanion) return
val companionContainingClassSymbol =
dispatchClassSymbol.getContainingDeclarationSymbol(context.session) as? FirRegularClassSymbol ?: return
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeHelpers.kt
+2 -2
View File
@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.name.ClassId
fun DiagnosticReporter.reportIfHasAnnotation(
declaration: FirDeclaration,
declaration: FirDeclaration,
annotationClassId: ClassId,
error: KtDiagnosticFactory0,
context: CheckerContext
) {
val annotation = declaration.getAnnotationByClassId(annotationClassId)
val annotation = declaration.getAnnotationByClassId(annotationClassId, context.session)
if (annotation != null) {
reportOn(annotation.source, error, context)
}
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt
+12 -11
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
@@ -51,7 +52,7 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker() {
private fun checkDeclaration(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirValueParameter) return // those are checked with the FirFunction
val objCNames = declaration.symbol.getObjCNames().filterNotNull()
val objCNames = declaration.symbol.getObjCNames(context.session).filterNotNull()
if (objCNames.isEmpty()) return
if (declaration is FirCallableDeclaration && declaration.isOverride) {
for (objCName in objCNames) {
@@ -115,20 +116,20 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker() {
}
}
private fun FirAnnotationContainer.getObjCName(): ObjCName? =
getAnnotationByClassId(objCNameClassId)?.let(::ObjCName)
private fun FirAnnotationContainer.getObjCName(session: FirSession): ObjCName? =
getAnnotationByClassId(objCNameClassId, session)?.let(::ObjCName)
private fun FirBasedSymbol<*>.getObjCName(): ObjCName? =
getAnnotationByClassId(objCNameClassId)?.let(::ObjCName)
private fun FirBasedSymbol<*>.getObjCName(session: FirSession): ObjCName? =
getAnnotationByClassId(objCNameClassId, session)?.let(::ObjCName)
fun FirBasedSymbol<*>.getObjCNames(): List<ObjCName?> = when (this) {
fun FirBasedSymbol<*>.getObjCNames(session: FirSession): List<ObjCName?> = when (this) {
is FirFunctionSymbol<*> -> buildList {
add((this@getObjCNames as FirBasedSymbol<*>).getObjCName())
add(resolvedReceiverTypeRef?.getObjCName())
add(receiverParameter?.getObjCName())
valueParameterSymbols.forEach { add(it.getObjCName()) }
add((this@getObjCNames as FirBasedSymbol<*>).getObjCName(session))
add(resolvedReceiverTypeRef?.getObjCName(session))
add(receiverParameter?.getObjCName(session))
valueParameterSymbols.forEach { add(it.getObjCName(session)) }
}
else -> listOf(getObjCName())
else -> listOf(getObjCName(session))
}
}
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameOverridesChecker.kt
+4 -2
View File
@@ -44,9 +44,11 @@ object FirNativeObjCNameOverridesChecker : FirClassChecker() {
) {
val overriddenSymbols = firTypeScope.retrieveDirectOverriddenOf(memberSymbol)
if (overriddenSymbols.isEmpty()) return
val objCNames = overriddenSymbols.map { it.getFirstBaseSymbol(firTypeScope).getObjCNames() }
val objCNames = overriddenSymbols.map { it.getFirstBaseSymbol(firTypeScope).getObjCNames(context.session) }
if (!objCNames.allNamesEquals()) {
val containingDeclarations = overriddenSymbols.mapNotNull { it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) }
val containingDeclarations = overriddenSymbols.mapNotNull {
it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
}
reporter.reportOn(
declarationToReport.source,
INCOMPATIBLE_OBJC_NAME_OVERRIDE,
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementAnnotationChecker.kt
+6 -4
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker
import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
@@ -24,7 +25,8 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return
val (objCAnnotation, swiftAnnotation) = declaration.findMetaAnnotations()
val session = context.session
val (objCAnnotation, swiftAnnotation) = declaration.findMetaAnnotations(session)
if (objCAnnotation == null && swiftAnnotation == null) return
if (objCAnnotation != null && swiftAnnotation != null) {
reporter.reportOn(
@@ -33,7 +35,7 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() {
context
)
}
val targets = declaration.getAllowedAnnotationTargets()
val targets = declaration.getAllowedAnnotationTargets(session)
val unsupportedTargets = targets - supportedTargets
if (unsupportedTargets.isNotEmpty()) {
objCAnnotation?.let { reporter.reportOn(it.source, FirNativeErrors.INVALID_OBJC_REFINEMENT_TARGETS, context) }
@@ -41,11 +43,11 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() {
}
}
private fun FirRegularClass.findMetaAnnotations(): Pair<FirAnnotation?, FirAnnotation?> {
private fun FirRegularClass.findMetaAnnotations(session: FirSession): Pair<FirAnnotation?, FirAnnotation?> {
var objCAnnotation: FirAnnotation? = null
var swiftAnnotation: FirAnnotation? = null
for (annotation in annotations) {
when (annotation.toAnnotationClassId()) {
when (annotation.toAnnotationClassId(session)) {
hidesFromObjCClassId -> objCAnnotation = annotation
refinesInSwiftClassId -> swiftAnnotation = annotation
}
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementChecker.kt
+1 -1
View File
@@ -46,7 +46,7 @@ object FirNativeObjCRefinementChecker : FirCallableDeclarationChecker() {
for (annotation in annotations) {
val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty()
for (metaAnnotation in metaAnnotations) {
when (metaAnnotation.toAnnotationClassId()) {
when (metaAnnotation.toAnnotationClassId(session)) {
hidesFromObjCClassId -> {
objCAnnotations.add(annotation)
break
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCRefinementOverridesChecker.kt
+1 -1
View File
@@ -85,7 +85,7 @@ object FirNativeObjCRefinementOverridesChecker : FirClassChecker() {
for (annotation in resolvedAnnotationsWithClassIds) {
val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty()
for (metaAnnotation in metaAnnotations) {
when (metaAnnotation.toAnnotationClassId()) {
when (metaAnnotation.toAnnotationClassId(session)) {
hidesFromObjCClassId -> {
hasObjC = true
break
compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt
+2 -2
View File
@@ -45,7 +45,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
)
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val throwsAnnotation = declaration.getAnnotationByClassId(throwsClassId) as? FirAnnotationCall
val throwsAnnotation = declaration.getAnnotationByClassId(throwsClassId, context.session) as? FirAnnotationCall
if (!checkInheritance(declaration, throwsAnnotation, context, reporter)) return
@@ -123,7 +123,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
val annotation = if (overriddenFunction.isSubstitutionOrIntersectionOverride) {
null
} else {
overriddenFunction.getAnnotationByClassId(throwsClassId) as? FirAnnotationCall
overriddenFunction.getAnnotationByClassId(throwsClassId, context.session) as? FirAnnotationCall
}
getInheritedThrows(annotation, overriddenFunction)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt
+21 -21
View File
@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.name.StandardClassIds.Annotations.ParameterNames
import org.jetbrains.kotlin.resolve.UseSiteTargetsList
import org.jetbrains.kotlin.resolve.checkers.OptInNames
fun FirRegularClass.getRetention(): AnnotationRetention {
return getRetentionAnnotation()?.getRetention() ?: AnnotationRetention.RUNTIME
fun FirRegularClass.getRetention(session: FirSession): AnnotationRetention {
return getRetentionAnnotation(session)?.getRetention() ?: AnnotationRetention.RUNTIME
}
fun FirAnnotation.getRetention(): AnnotationRetention {
@@ -51,24 +51,24 @@ fun FirAnnotation.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTa
val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType)
?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets
annotationClassSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
return annotationClassSymbol.getAllowedAnnotationTargets()
return annotationClassSymbol.getAllowedAnnotationTargets(session)
}
internal fun FirAnnotation.getAnnotationClassForOptInMarker(session: FirSession): FirRegularClassSymbol? {
val lookupTag = annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return null
val annotationClassSymbol = lookupTag.toSymbol(session) as? FirRegularClassSymbol ?: return null
if (annotationClassSymbol.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) == null) {
if (annotationClassSymbol.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) == null) {
return null
}
return annotationClassSymbol
}
fun FirRegularClass.getAllowedAnnotationTargets(): Set<KotlinTarget> {
return symbol.getAllowedAnnotationTargets()
fun FirRegularClass.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTarget> {
return symbol.getAllowedAnnotationTargets(session)
}
fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set<KotlinTarget> {
val targetAnnotation = getTargetAnnotation() ?: return defaultAnnotationTargets
fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTarget> {
val targetAnnotation = getTargetAnnotation(session) ?: return defaultAnnotationTargets
val arguments = targetAnnotation.findArgumentByName(ParameterNames.targetAllowedTargets)?.unfoldArrayOrVararg().orEmpty()
return arguments.mapNotNullTo(mutableSetOf()) { argument ->
@@ -78,16 +78,16 @@ fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set<KotlinTarget> {
}
}
fun FirDeclaration.getRetentionAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Retention)
fun FirDeclaration.getRetentionAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Retention, session)
}
fun FirDeclaration.getTargetAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Target)
fun FirDeclaration.getTargetAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Target, session)
}
fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Target)
fun FirClassLikeSymbol<*>.getTargetAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Target, session)
}
fun FirExpression.extractClassesFromArgument(session: FirSession): List<FirRegularClassSymbol> {
@@ -123,7 +123,7 @@ fun checkRepeatedAnnotation(
}
fun FirAnnotation.isRepeatable(session: FirSession): Boolean {
val annotationClassId = this.toAnnotationClassId() ?: return false
val annotationClassId = this.toAnnotationClassId(session) ?: return false
if (annotationClassId.isLocal) return false
val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: return false
@@ -131,18 +131,18 @@ fun FirAnnotation.isRepeatable(session: FirSession): Boolean {
}
fun FirClassLikeSymbol<*>.containsRepeatableAnnotation(session: FirSession): Boolean {
if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable) != null) return true
if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable) != null ||
getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable) != null
if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session) != null) return true
if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable, session) != null ||
getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable, session) != null
) {
return session.languageVersionSettings.supportsFeature(LanguageFeature.RepeatableAnnotations) ||
getAnnotationRetention() == AnnotationRetention.SOURCE && origin is FirDeclarationOrigin.Java
getAnnotationRetention(session) == AnnotationRetention.SOURCE && origin is FirDeclarationOrigin.Java
}
return false
}
fun FirClassLikeSymbol<*>.getAnnotationRetention(): AnnotationRetention {
return getAnnotationByClassId(StandardClassIds.Annotations.Retention)?.getRetention() ?: AnnotationRetention.RUNTIME
fun FirClassLikeSymbol<*>.getAnnotationRetention(session: FirSession): AnnotationRetention {
return getAnnotationByClassId(StandardClassIds.Annotations.Retention, session)?.getRetention() ?: AnnotationRetention.RUNTIME
}
fun FirAnnotationContainer.getDefaultUseSiteTarget(
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt
+4 -3
View File
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.modality
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -126,7 +125,9 @@ internal fun checkConstantArguments(
val symbol = calleeReference.resolvedSymbol as? FirNamedFunctionSymbol ?: return ConstantArgumentKind.NOT_CONST
@OptIn(SymbolInternals::class)
if (symbol.fir.getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION) == null) return ConstantArgumentKind.NOT_CONST
if (symbol.fir.getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION, session) == null) {
return ConstantArgumentKind.NOT_CONST
}
for (exp in expression.arguments.plus(expression.dispatchReceiver).plus(expression.extensionReceiver)) {
if (exp is FirNoReceiverExpression) continue
@@ -152,7 +153,7 @@ internal fun checkConstantArguments(
@OptIn(SymbolInternals::class)
val property = propertySymbol.fir
when {
property.unwrapFakeOverrides().getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION) != null -> {
property.unwrapFakeOverrides().getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION, session) != null -> {
return checkConstantArguments(expression.dispatchReceiver, session)
}
propertySymbol.isLocal || propertySymbol.callableId.className?.isRoot == false -> return ConstantArgumentKind.NOT_CONST
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt
+2 -2
View File
@@ -293,8 +293,8 @@ val FirValueParameter.hasValOrVar: Boolean
fun KotlinTypeMarker.isSupertypeOf(context: TypeCheckerProviderContext, type: KotlinTypeMarker?): Boolean =
type != null && AbstractTypeChecker.isSubtypeOf(context, type, this)
fun FirMemberDeclaration.isInlineOnly(): Boolean =
isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID)
fun FirMemberDeclaration.isInlineOnly(session: FirSession): Boolean =
isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID, session)
fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean {
val subtypeFullyExpanded = subtype.fullyExpandedType(context.session)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt
+4 -2
View File
@@ -64,7 +64,9 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin
// TODO: use-site targeted annotations
fun FirDeclaration.consider() {
val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin)?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion)
val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin, session)?.findArgumentByName(
StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion
)
val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
if (apiVersion != null) {
// TODO: combine wasExperimentalMarkerClasses in case of several associated declarations with the same maximal API version
@@ -97,7 +99,7 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin
}
private fun FirDeclaration.loadWasExperimentalMarkerClasses(session: FirSession): List<FirRegularClassSymbol> {
val wasExperimental = getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) ?: return emptyList()
val wasExperimental = getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID, session) ?: return emptyList()
val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList()
return annotationClasses.extractClassesFromArgument(session)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationClassDeclarationChecker.kt
+4 -3
View File
@@ -44,10 +44,11 @@ object FirAnnotationClassDeclarationChecker : FirRegularClassChecker() {
checkAnnotationClassMember(member, context, reporter)
}
if (declaration.getRetention() != AnnotationRetention.SOURCE &&
KotlinTarget.EXPRESSION in declaration.getAllowedAnnotationTargets()
val session = context.session
if (declaration.getRetention(session) != AnnotationRetention.SOURCE &&
KotlinTarget.EXPRESSION in declaration.getAllowedAnnotationTargets(session)
) {
val target = declaration.getRetentionAnnotation() ?: declaration.getTargetAnnotation() ?: declaration
val target = declaration.getRetentionAnnotation(session) ?: declaration.getTargetAnnotation(session) ?: declaration
reporter.reportOn(target.source, FirErrors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION, context)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt
+4 -3
View File
@@ -433,15 +433,16 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
private fun checkNothingToInline(function: FirSimpleFunction, context: CheckerContext, reporter: DiagnosticReporter) {
if (function.isExpect || function.isSuspend) return
if (function.typeParameters.any { it.symbol.isReified }) return
val session = context.session
val hasInlinableParameters =
function.valueParameters.any { param ->
val type = param.returnTypeRef.coneType
!param.isNoinline && !type.isNullable
&& (type.isFunctionalType(context.session) || type.isSuspendFunctionType(context.session))
&& (type.isFunctionalType(session) || type.isSuspendFunctionType(session))
}
if (hasInlinableParameters) return
if (function.isInlineOnly()) return
if (function.returnTypeRef.needsMultiFieldValueClassFlattening(context.session)) return
if (function.isInlineOnly(session)) return
if (function.returnTypeRef.needsMultiFieldValueClassFlattening(session)) return
reporter.reportOn(function.source, FirErrors.NOTHING_TO_INLINE, context)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInAnnotationClassChecker.kt
+6 -5
View File
@@ -20,15 +20,16 @@ import org.jetbrains.kotlin.resolve.checkers.OptInNames
object FirOptInAnnotationClassChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return
if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) == null) return
if (declaration.getRetention() == AnnotationRetention.SOURCE) {
val target = declaration.getRetentionAnnotation()
val session = context.session
if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) == null) return
if (declaration.getRetention(session) == AnnotationRetention.SOURCE) {
val target = declaration.getRetentionAnnotation(session)
reporter.reportOn(target?.source, FirErrors.OPT_IN_MARKER_WITH_WRONG_RETENTION, context)
}
val wrongTargets = declaration.getAllowedAnnotationTargets().intersect(OptInDescription.WRONG_TARGETS_FOR_MARKER)
val wrongTargets = declaration.getAllowedAnnotationTargets(session).intersect(OptInDescription.WRONG_TARGETS_FOR_MARKER)
if (wrongTargets.isNotEmpty()) {
val target = declaration.getTargetAnnotation()
val target = declaration.getTargetAnnotation(session)
reporter.reportOn(
target?.source,
FirErrors.OPT_IN_MARKER_WITH_WRONG_TARGET,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOptInMarkedDeclarationChecker.kt
+1 -1
View File
@@ -25,7 +25,7 @@ object FirOptInMarkedDeclarationChecker : FirBasicDeclarationChecker() {
}
if (useSiteTarget == SETTER_PARAMETER ||
(useSiteTarget != PROPERTY && useSiteTarget != PROPERTY_SETTER && declaration is FirValueParameter &&
KotlinTarget.VALUE_PARAMETER in annotationClass.getAllowedAnnotationTargets())
KotlinTarget.VALUE_PARAMETER in annotationClass.getAllowedAnnotationTargets(context.session))
) {
reporter.reportOn(annotation.source, FirErrors.OPT_IN_MARKER_ON_WRONG_TARGET, "parameter", context)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPublishedApiChecker.kt
+1 -1
View File
@@ -22,7 +22,7 @@ object FirPublishedApiChecker : FirBasicDeclarationChecker() {
if (declaration !is FirMemberDeclaration) return
if (declaration is FirValueParameter) return
if (declaration.visibility == Visibilities.Internal) return
val annotation = declaration.getAnnotationByClassId(StandardClassIds.Annotations.PublishedApi) ?: return
val annotation = declaration.getAnnotationByClassId(StandardClassIds.Annotations.PublishedApi, context.session) ?: return
reporter.reportOn(annotation.source, FirErrors.NON_INTERNAL_PUBLISHED_API, context)
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirTypeParameterBoundsChecker.kt
+1 -1
View File
@@ -34,7 +34,7 @@ object FirTypeParameterBoundsChecker : FirTypeParameterChecker() {
checkFinalUpperBounds(declaration, containingDeclaration, context, reporter)
checkExtensionFunctionTypeBound(declaration, context, reporter)
if ((containingDeclaration as? FirMemberDeclaration)?.isInlineOnly() != true) {
if ((containingDeclaration as? FirMemberDeclaration)?.isInlineOnly(context.session) != true) {
checkOnlyOneTypeParameterBound(declaration, context, reporter)
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt
+1 -1
View File
@@ -98,7 +98,7 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() {
context: CheckerContext
) {
with(FirOptInUsageBaseChecker) {
if (classSymbol.loadExperimentalityForMarkerAnnotation() == null) {
if (classSymbol.loadExperimentalityForMarkerAnnotation(context.session) == null) {
reporter.reportOn(
source,
FirErrors.OPT_IN_ARGUMENT_IS_NOT_MARKER,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt
+16 -10
View File
@@ -63,10 +63,13 @@ object FirOptInUsageBaseChecker {
}
// Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name
fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName: String? = null): Experimentality? {
fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(
session: FirSession,
annotatedOwnerClassName: String? = null
): Experimentality? {
lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
@OptIn(SymbolInternals::class)
return fir.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName)
return fir.loadExperimentalityForMarkerAnnotation(session, annotatedOwnerClassName)
}
fun FirBasedSymbol<*>.loadExperimentalitiesFromAnnotationTo(session: FirSession, result: MutableCollection<Experimentality>) {
@@ -90,14 +93,14 @@ object FirOptInUsageBaseChecker {
result.addIfNotNull(
annotationType.lookupTag.toFirRegularClassSymbol(
session
)?.loadExperimentalityForMarkerAnnotation(className)
)?.loadExperimentalityForMarkerAnnotation(session, className)
)
if (fromSupertype) {
if (annotationType.lookupTag.classId == OptInNames.SUBCLASS_OPT_IN_REQUIRED_CLASS_ID) {
val annotationClass = annotation.findArgumentByName(OptInNames.OPT_IN_ANNOTATION_CLASS) ?: continue
result.addIfNotNull(
annotationClass.extractClassFromArgument(session)
?.loadExperimentalityForMarkerAnnotation()?.copy(fromSupertype = true)
?.loadExperimentalityForMarkerAnnotation(session)?.copy(fromSupertype = true)
)
}
}
@@ -159,12 +162,12 @@ object FirOptInUsageBaseChecker {
fir.loadExperimentalitiesFromAnnotationTo(session, result, fromSupertype)
if (fir.getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID) != null) {
if (fir.getAnnotationByClassId(OptInNames.WAS_EXPERIMENTAL_CLASS_ID, session) != null) {
val accessibility = fir.checkSinceKotlinVersionAccessibility(context)
if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) {
accessibility.markerClasses.forEach {
it.lazyResolveToPhase(FirResolvePhase.STATUS)
result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation())
result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation(session))
}
}
}
@@ -241,8 +244,11 @@ object FirOptInUsageBaseChecker {
}
// Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name
private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName: String? = null): Experimentality? {
val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID)
private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(
session: FirSession,
annotatedOwnerClassName: String? = null
): Experimentality? {
val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session)
?: return null
val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression
@@ -321,11 +327,11 @@ object FirOptInUsageBaseChecker {
annotationClassId: ClassId,
fromSupertype: Boolean
): Boolean {
return getAnnotationByClassId(annotationClassId) != null || isAnnotatedWithOptIn(session, annotationClassId) ||
return getAnnotationByClassId(annotationClassId, session) != null || isAnnotatedWithOptIn(annotationClassId, session) ||
fromSupertype && isAnnotatedWithSubclassOptInRequired(session, annotationClassId)
}
private fun FirAnnotationContainer.isAnnotatedWithOptIn(session: FirSession, annotationClassId: ClassId): Boolean {
private fun FirAnnotationContainer.isAnnotatedWithOptIn(annotationClassId: ClassId, session: FirSession): Boolean {
for (annotation in annotations) {
val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType
if (coneType?.lookupTag?.classId != OptInNames.OPT_IN_CLASS_ID) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSuspendCallChecker.kt
+1 -1
View File
@@ -189,7 +189,7 @@ object FirSuspendCallChecker : FirQualifiedAccessExpressionChecker() {
when (this) {
is ConeClassLikeType -> {
val regularClassSymbol = fullyExpandedType(session).lookupTag.toFirRegularClassSymbol(session) ?: return false
if (regularClassSymbol.getAnnotationByClassId(StandardClassIds.Annotations.RestrictsSuspension) != null) {
if (regularClassSymbol.getAnnotationByClassId(StandardClassIds.Annotations.RestrictsSuspension, session) != null) {
return true
}
return regularClassSymbol.resolvedSuperTypes.any { it.isRestrictSuspensionReceiver(session) }
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt
+3 -1
View File
@@ -40,7 +40,9 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
if (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) {
if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) {
reporter.reportOn(source, OPT_IN_CAN_ONLY_BE_USED_AS_ANNOTATION, context)
} else if (symbol is FirRegularClassSymbol && symbol.fir.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) != null) {
} else if (symbol is FirRegularClassSymbol &&
symbol.fir.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, context.session) != null
) {
reporter.reportOn(source, OPT_IN_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_OPT_IN, context)
}
}
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt
+1 -3
View File
@@ -8,13 +8,11 @@ package org.jetbrains.kotlin.fir.deserialization
import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.*
import org.jetbrains.kotlin.fir.declarations.comparators.FirMemberDeclarationComparator
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.declarations.utils.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
@@ -231,7 +229,7 @@ fun deserializeClassToSymbol(
sourceElement = containerSource
replaceDeprecationsProvider(getDeprecationsProvider(session.firCachesFactory))
replaceDeprecationsProvider(getDeprecationsProvider(session))
classProto.getExtensionOrNull(JvmProtoBuf.classModuleName)?.let { idx ->
moduleName = nameResolver.getString(idx)
compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt
+3 -5
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.deserialization
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.*
@@ -16,7 +15,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.declarations.utils.sourceElement
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -431,7 +429,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
}
this.containerSource = c.containerSource
this.initializer = c.constDeserializer.loadConstant(proto, symbol.callableId, c.nameResolver)
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory)
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false)
proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver)
}.apply {
@@ -514,7 +512,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
)
annotations +=
c.annotationDeserializer.loadFunctionAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable)
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory)
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false)
this.containerSource = c.containerSource
proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver)
@@ -594,7 +592,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
annotations +=
c.annotationDeserializer.loadConstructorAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable)
containerSource = c.containerSource
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory)
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false)
contextReceivers.addAll(createContextReceiversForClass(classProto))
}.build().apply {
compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt
+1 -1
View File
@@ -907,7 +907,7 @@ class FirElementSerializer private constructor(
private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List<FirAnnotation>): List<Int> =
annotations
.filter {
it.toAnnotationClassId()?.asSingleFqName() == RequireKotlinConstants.FQ_NAME
it.toAnnotationClassId(session)?.asSingleFqName() == RequireKotlinConstants.FQ_NAME
}
.mapNotNull(::serializeVersionRequirementFromRequireKotlin)
.map(::get)
compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmSerializerExtension.kt
+1 -1
View File
@@ -275,7 +275,7 @@ class FirJvmSerializerExtension(
}
private fun FirProperty.isJvmFieldPropertyInInterfaceCompanion(): Boolean {
if (!hasJvmFieldAnnotation) return false
if (!hasJvmFieldAnnotation(session)) return false
val containerSymbol = (dispatchReceiverType as? ConeClassLikeType)?.lookupTag?.toFirRegularClassSymbol(session)
// Note: companions are anyway forbidden in local classes
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt
+1 -1
View File
@@ -785,7 +785,7 @@ class Fir2IrDeclarationStorage(
hasExplicitBackingField -> backingField?.visibility ?: status.visibility
isLateInit -> setter?.visibility ?: status.visibility
isConst -> status.visibility
hasJvmFieldAnnotation -> status.visibility
hasJvmFieldAnnotation(session) -> status.visibility
else -> Visibilities.Private
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt
+1 -1
View File
@@ -135,7 +135,7 @@ class Fir2IrTypeConverter(
}
}
if (isExtensionFunctionType && annotations.getAnnotationsByClassId(ExtensionFunctionType).isEmpty()) {
if (isExtensionFunctionType && annotations.getAnnotationsByClassId(ExtensionFunctionType, session).isEmpty()) {
builtIns.extensionFunctionTypeAnnotationConstructorCall()?.let {
typeAnnotations += it
}
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt
+2 -1
View File
@@ -642,6 +642,7 @@ class CallAndReferenceGenerator(
fun convertToIrConstructorCall(annotation: FirAnnotation): IrExpression {
val coneType = annotation.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>()
?.fullyExpandedType(session) as? ConeLookupTagBasedType
val type = coneType?.toIrType()
val symbol = type?.classifierOrNull
return annotation.convertWithOffsets { startOffset, endOffset ->
@@ -693,7 +694,7 @@ class CallAndReferenceGenerator(
return buildAnnotationCall {
useSiteTarget = this@toAnnotationCall.useSiteTarget
annotationTypeRef = this@toAnnotationCall.annotationTypeRef
val symbol = annotationTypeRef.coneType.toSymbol(session) as? FirRegularClassSymbol ?: return null
val symbol = annotationTypeRef.coneType.fullyExpandedType(session).toSymbol(session) as? FirRegularClassSymbol ?: return null
val constructorSymbol = symbol.declarationSymbols.firstIsInstanceOrNull<FirConstructorSymbol>() ?: return null
val argumentToParameterToMapping = constructorSymbol.valueParameterSymbols.mapNotNull {
val parameter = it.fir
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt
+4 -4
View File
@@ -334,14 +334,14 @@ class DelegatedMemberGenerator(
val wrappedSymbol = wrapped.symbol as? S ?: return null
@Suppress("UNCHECKED_CAST")
return (wrappedSymbol.unwrapCallRepresentative().fir as D).takeIf { !shouldSkipDelegationFor(it) }
return (wrappedSymbol.unwrapCallRepresentative().fir as D).takeIf { !shouldSkipDelegationFor(it, session) }
}
private fun shouldSkipDelegationFor(unwrapped: FirCallableDeclaration): Boolean {
private fun shouldSkipDelegationFor(unwrapped: FirCallableDeclaration, session: FirSession): Boolean {
// See org.jetbrains.kotlin.resolve.jvm.JvmDelegationFilter
return (unwrapped is FirSimpleFunction && unwrapped.isDefaultJavaMethod()) ||
unwrapped.hasAnnotation(JVM_DEFAULT_CLASS_ID) ||
unwrapped.hasAnnotation(PLATFORM_DEPENDENT_CLASS_ID)
unwrapped.hasAnnotation(JVM_DEFAULT_CLASS_ID, session) ||
unwrapped.hasAnnotation(PLATFORM_DEPENDENT_CLASS_ID, session)
}
private fun FirSimpleFunction.isDefaultJavaMethod(): Boolean =
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/AbstractFir2IrLazyFunction.kt
+2 -2
View File
@@ -95,8 +95,8 @@ abstract class AbstractFir2IrLazyFunction<F : FirCallableDeclaration>(
}
private fun hasJvmStaticAnnotation(): Boolean {
return fir.hasAnnotation(JVM_STATIC_CLASS_ID) ||
(fir as? FirPropertyAccessor)?.propertySymbol?.fir?.hasAnnotation(JVM_STATIC_CLASS_ID) == true
return fir.hasAnnotation(JVM_STATIC_CLASS_ID, session) ||
(fir as? FirPropertyAccessor)?.propertySymbol?.fir?.hasAnnotation(JVM_STATIC_CLASS_ID, session) == true
}
protected fun createThisReceiverParameter(thisType: IrType, explicitReceiver: FirReceiverParameter? = null): IrValueParameter {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaFacade.kt
+1 -1
View File
@@ -199,7 +199,7 @@ abstract class FirJavaFacade(
}
}
firJavaClass.replaceSuperTypeRefs(enhancedSuperTypes)
firJavaClass.replaceDeprecationsProvider(firJavaClass.getDeprecationsProvider(session.firCachesFactory))
firJavaClass.replaceDeprecationsProvider(firJavaClass.getDeprecationsProvider(session))
return firJavaClass
}
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt
+3 -1
View File
@@ -35,7 +35,9 @@ class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUp
private val jvmRecordUpdater = DelegatedConstructorCallTransformer(session)
override fun updateSupertypesIfNeeded(firClass: FirClass, scopeSession: ScopeSession) {
if (!(firClass is FirRegularClass && firClass.isData && firClass.hasAnnotationSafe(StandardClassIds.Annotations.JvmRecord))) return
if (firClass !is FirRegularClass || !firClass.isData ||
!firClass.hasAnnotationSafe(StandardClassIds.Annotations.JvmRecord, session)
) return
var anyFound = false
var hasExplicitSuperClass = false
val newSuperTypeRefs = firClass.superTypeRefs.mapTo(mutableListOf()) {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaField.kt
+1 -2
View File
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.FirImplementationDetail
import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
@@ -65,7 +64,7 @@ class FirJavaField @FirImplementationDetail constructor(
get() = lazyInitializer.value
override val deprecationsProvider: DeprecationsProvider by lazy {
annotations.getDeprecationsProviderFromAnnotations(fromJava = true, moduleData.session.firCachesFactory)
annotations.getDeprecationsProviderFromAnnotations(moduleData.session, fromJava = true)
}
override val contextReceivers: List<FirContextReceiver>
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmClassFileBasedSymbolProvider.kt
+1 -2
View File
@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.descriptors.SourceElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.ThreadSafeMutableState
import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
import org.jetbrains.kotlin.fir.declarations.getDeprecationsProvider
import org.jetbrains.kotlin.fir.deserialization.*
@@ -158,7 +157,7 @@ class JvmClassFileBasedSymbolProvider(
kotlinClass.byteContent,
)
symbol.fir.replaceAnnotations(annotations.toMutableOrEmpty())
symbol.fir.replaceDeprecationsProvider(symbol.fir.getDeprecationsProvider(session.firCachesFactory))
symbol.fir.replaceDeprecationsProvider(symbol.fir.getDeprecationsProvider(session))
}
private fun String?.toPath(): Path? {
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt
+2 -2
View File
@@ -169,7 +169,7 @@ class FirSignatureEnhancement(
delegateGetter = enhancedGetterSymbol.fir as FirSimpleFunction
delegateSetter = enhancedSetterSymbol?.fir as FirSimpleFunction?
status = firElement.status
deprecationsProvider = getDeprecationsProviderFromAccessors(delegateGetter, delegateSetter, session.firCachesFactory)
deprecationsProvider = getDeprecationsProviderFromAccessors(session, delegateGetter, delegateSetter)
}.symbol
}
else -> {
@@ -332,7 +332,7 @@ class FirSignatureEnhancement(
}
this.valueParameters += newValueParameters
annotations += firMethod.annotations
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = true, session.firCachesFactory)
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(session, fromJava = true)
}.build().apply {
if (isJavaRecordComponent) {
this.isJavaRecordComponent = true
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt
+1 -2
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.java.scopes
import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy
import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
@@ -89,7 +88,7 @@ class JavaClassUseSiteMemberScope(
chooseModalityForAccessor(property, delegateGetter)
}
)
deprecationsProvider = getDeprecationsProviderFromAccessors(delegateGetter, delegateSetter, session.firCachesFactory)
deprecationsProvider = getDeprecationsProviderFromAccessors(session, delegateGetter, delegateSetter)
}.symbol
}
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt
+40 -38
View File
@@ -22,21 +22,21 @@ import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
private fun FirAnnotation.toAnnotationLookupTag(): ConeClassLikeLookupTag? =
private fun FirAnnotation.toAnnotationLookupTag(session: FirSession): ConeClassLikeLookupTag? =
// this cast fails when we have generic-typed annotations @T
(annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag
(annotationTypeRef.coneType as? ConeClassLikeType)?.fullyExpandedType(session)?.lookupTag
private fun FirAnnotation.toAnnotationLookupTagSafe(): ConeClassLikeLookupTag? =
annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag
private fun FirAnnotation.toAnnotationLookupTagSafe(session: FirSession): ConeClassLikeLookupTag? =
annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.fullyExpandedType(session)?.lookupTag
fun FirAnnotation.toAnnotationClassId(): ClassId? =
toAnnotationLookupTag()?.classId
fun FirAnnotation.toAnnotationClassId(session: FirSession): ClassId? =
toAnnotationLookupTag(session)?.classId
fun FirAnnotation.toAnnotationClassIdSafe(): ClassId? =
toAnnotationLookupTagSafe()?.classId
private fun FirAnnotation.toAnnotationClassIdSafe(session: FirSession): ClassId? =
toAnnotationLookupTagSafe(session)?.classId
private fun FirAnnotation.toAnnotationClass(session: FirSession): FirRegularClass? =
toAnnotationLookupTag()?.toSymbol(session)?.fir as? FirRegularClass
toAnnotationLookupTag(session)?.toSymbol(session)?.fir as? FirRegularClass
// TODO: this is temporary solution, we need something better
private val FirExpression.callableNameOfMetaAnnotationArgument: Name?
@@ -52,22 +52,22 @@ fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAn
annotations.filter { annotation ->
val firAnnotationClass = annotation.toAnnotationClass(session)
firAnnotationClass != null && firAnnotationClass.annotations.none { meta ->
meta.toAnnotationClassId() == StandardClassIds.Annotations.Retention &&
meta.toAnnotationClassId(session) == StandardClassIds.Annotations.Retention &&
meta.findArgumentByName(StandardClassIds.Annotations.ParameterNames.retentionValue)
?.callableNameOfMetaAnnotationArgument == sourceName
}
}
inline val FirProperty.hasJvmFieldAnnotation: Boolean
get() = annotations.any { it.isJvmFieldAnnotation }
@Suppress("NOTHING_TO_INLINE")
inline fun FirProperty.hasJvmFieldAnnotation(session: FirSession): Boolean = annotations.any { it.isJvmFieldAnnotation(session) }
val FirAnnotation.isJvmFieldAnnotation: Boolean
get() = toAnnotationClassId() == StandardClassIds.Annotations.JvmField
fun FirAnnotation.isJvmFieldAnnotation(session: FirSession): Boolean =
toAnnotationClassId(session) == StandardClassIds.Annotations.JvmField
fun FirAnnotation.useSiteTargetsFromMetaAnnotation(session: FirSession): Set<AnnotationUseSiteTarget> {
return toAnnotationClass(session)
?.annotations
?.find { it.toAnnotationClassId() == StandardClassIds.Annotations.Target }
?.find { it.toAnnotationClassId(session) == StandardClassIds.Annotations.Target }
?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.targetAllowedTargets)
?.unwrapVarargValue()
?.toAnnotationUseSiteTargets()
@@ -101,45 +101,47 @@ private val USE_SITE_TARGET_NAME_MAP = mapOf(
private val DEFAULT_USE_SITE_TARGETS: Set<AnnotationUseSiteTarget> =
USE_SITE_TARGET_NAME_MAP.values.fold(setOf<AnnotationUseSiteTarget>()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE)
fun FirDeclaration.hasAnnotation(classId: ClassId): Boolean {
return annotations.hasAnnotation(classId)
fun FirDeclaration.hasAnnotation(classId: ClassId, session: FirSession): Boolean {
return annotations.hasAnnotation(classId, session)
}
fun FirDeclaration.hasAnnotationSafe(classId: ClassId): Boolean {
return annotations.hasAnnotationSafe(classId)
fun FirDeclaration.hasAnnotationSafe(classId: ClassId, session: FirSession): Boolean {
return annotations.hasAnnotationSafe(classId, session)
}
fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId): Boolean {
return resolvedAnnotationsWithClassIds.hasAnnotation(classId)
fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId, session: FirSession): Boolean {
return resolvedAnnotationsWithClassIds.hasAnnotation(classId, session)
}
fun List<FirAnnotation>.hasAnnotation(classId: ClassId): Boolean {
return this.any { it.toAnnotationClassId() == classId }
fun List<FirAnnotation>.hasAnnotation(classId: ClassId, session: FirSession): Boolean {
return this.any { it.toAnnotationClassId(session) == classId }
}
fun List<FirAnnotation>.hasAnnotationSafe(classId: ClassId): Boolean {
return this.any { it.toAnnotationClassIdSafe() == classId }
fun List<FirAnnotation>.hasAnnotationSafe(classId: ClassId, session: FirSession): Boolean {
return this.any { it.toAnnotationClassIdSafe(session) == classId }
}
fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(classId: ClassId): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration {
return fir.getAnnotationByClassId(classId)
fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(
classId: ClassId,
session: FirSession
): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration {
return fir.getAnnotationByClassId(classId, session)
}
fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotation? {
return annotations.getAnnotationByClassId(classId)
fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId, session: FirSession): FirAnnotation? {
return annotations.getAnnotationByClassId(classId, session)
}
fun List<FirAnnotation>.getAnnotationByClassId(classId: ClassId): FirAnnotation? {
return find {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == classId
}
fun List<FirAnnotation>.getAnnotationByClassId(classId: ClassId, session: FirSession): FirAnnotation? {
return getAnnotationsByClassId(classId, session).firstOrNull()
}
fun FirAnnotationContainer.getAnnotationsByClassId(classId: ClassId): List<FirAnnotation> = annotations.getAnnotationsByClassId(classId)
fun FirAnnotationContainer.getAnnotationsByClassId(classId: ClassId, session: FirSession): List<FirAnnotation> =
annotations.getAnnotationsByClassId(classId, session)
fun List<FirAnnotation>.getAnnotationsByClassId(classId: ClassId): List<FirAnnotation> {
fun List<FirAnnotation>.getAnnotationsByClassId(classId: ClassId, session: FirSession): List<FirAnnotation> {
return filter {
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == classId
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.fullyExpandedType(session)?.lookupTag?.classId == classId
}
}
@@ -201,8 +203,8 @@ fun FirGetClassCall.getTargetType(): ConeKotlinType? {
return typeRef.coneType.typeArguments.getOrNull(0)?.type
}
fun FirAnnotationContainer.getJvmNameFromAnnotation(target: AnnotationUseSiteTarget? = null): String? {
val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName)
fun FirAnnotationContainer.getJvmNameFromAnnotation(session: FirSession, target: AnnotationUseSiteTarget? = null): String? {
val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName, session)
return annotationCalls.firstNotNullOfOrNull { call ->
call.getStringArgument(StandardClassIds.Annotations.ParameterNames.jvmNameName)
?.takeIf { target == null || call.useSiteTarget == target }
compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt
+22 -16
View File
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.caches.FirCachesFactory
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -90,33 +91,36 @@ fun FirBasedSymbol<*>.getDeprecation(apiVersion: ApiVersion, callSite: FirElemen
}
}
fun FirAnnotationContainer.getDeprecationsProvider(firCachesFactory: FirCachesFactory): DeprecationsProvider {
return extractDeprecationInfoPerUseSite().toDeprecationsProvider(firCachesFactory)
fun FirAnnotationContainer.getDeprecationsProvider(session: FirSession): DeprecationsProvider {
return extractDeprecationInfoPerUseSite(session).toDeprecationsProvider(session.firCachesFactory)
}
fun FirAnnotationContainer.extractDeprecationInfoPerUseSite(): DeprecationAnnotationInfoPerUseSiteStorage {
fun FirAnnotationContainer.extractDeprecationInfoPerUseSite(session: FirSession): DeprecationAnnotationInfoPerUseSiteStorage {
val fromJava = this is FirDeclaration && this.isJavaOrEnhancement
return buildDeprecationAnnotationInfoPerUseSiteStorage {
add(annotations.extractDeprecationAnnotationInfoPerUseSite(fromJava))
add(annotations.extractDeprecationAnnotationInfoPerUseSite(session, fromJava))
if (this@extractDeprecationInfoPerUseSite is FirProperty) {
add(getDeprecationsAnnotationInfoByUseSiteFromAccessors(getter, setter))
add(getDeprecationsAnnotationInfoByUseSiteFromAccessors(session, getter, setter))
}
}
}
fun getDeprecationsProviderFromAccessors(
session: FirSession,
getter: FirFunction?,
setter: FirFunction?,
firCachesFactory: FirCachesFactory
setter: FirFunction?
): DeprecationsProvider {
return getDeprecationsAnnotationInfoByUseSiteFromAccessors(getter, setter).toDeprecationsProvider(firCachesFactory)
return getDeprecationsAnnotationInfoByUseSiteFromAccessors(session, getter, setter).toDeprecationsProvider(session.firCachesFactory)
}
fun getDeprecationsAnnotationInfoByUseSiteFromAccessors(
session: FirSession,
getter: FirFunction?,
setter: FirFunction?
): DeprecationAnnotationInfoPerUseSiteStorage {
return buildDeprecationAnnotationInfoPerUseSiteStorage {
val setterDeprecations = setter?.extractDeprecationInfoPerUseSite()
val setterDeprecations = setter?.extractDeprecationInfoPerUseSite(session)
setterDeprecations?.storage?.forEach { (useSite, infos) ->
if (useSite == null) {
add(AnnotationUseSiteTarget.PROPERTY_SETTER, infos)
@@ -124,7 +128,7 @@ fun getDeprecationsAnnotationInfoByUseSiteFromAccessors(
add(useSite, infos)
}
}
val getterDeprecations = getter?.extractDeprecationInfoPerUseSite()
val getterDeprecations = getter?.extractDeprecationInfoPerUseSite(session)
getterDeprecations?.storage?.forEach { (useSite, infos) ->
if (useSite == null) {
add(AnnotationUseSiteTarget.PROPERTY_GETTER, infos)
@@ -136,11 +140,11 @@ fun getDeprecationsAnnotationInfoByUseSiteFromAccessors(
}
fun List<FirAnnotation>.getDeprecationsProviderFromAnnotations(
fromJava: Boolean,
firCachesFactory: FirCachesFactory
session: FirSession,
fromJava: Boolean
): DeprecationsProvider {
val deprecationAnnotationByUseSite = extractDeprecationAnnotationInfoPerUseSite(fromJava)
return deprecationAnnotationByUseSite.toDeprecationsProvider(firCachesFactory)
val deprecationAnnotationByUseSite = extractDeprecationAnnotationInfoPerUseSite(session, fromJava)
return deprecationAnnotationByUseSite.toDeprecationsProvider(session.firCachesFactory)
}
fun FirBasedSymbol<*>.getDeprecationForCallSite(
@@ -175,7 +179,7 @@ private fun FirAnnotation.getDeprecationLevel(): DeprecationLevelValue? {
}
private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
fromJava: Boolean
session: FirSession, fromJava: Boolean
): DeprecationAnnotationInfoPerUseSiteStorage {
@Suppress("RemoveExplicitTypeArguments")
val annotations = buildList<Pair<FirAnnotation, Boolean>> {
@@ -199,7 +203,9 @@ private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
} else {
val deprecationLevel = deprecated.getDeprecationLevel() ?: DeprecationLevelValue.WARNING
val propagatesToOverride = !fromJavaAnnotation && !fromJava
val deprecatedSinceKotlin = getAnnotationsByClassId(StandardClassIds.Annotations.DeprecatedSinceKotlin).firstOrNull()
val deprecatedSinceKotlin = getAnnotationsByClassId(
StandardClassIds.Annotations.DeprecatedSinceKotlin, session
).firstOrNull()
val message = deprecated.getStringArgument(ParameterNames.deprecatedMessage)
val deprecatedInfo =
compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt
+2 -2
View File
@@ -76,11 +76,11 @@ fun FirSymbolProvider.getSymbolByLookupTag(lookupTag: ConeClassLikeLookupTag): F
return lookupTag.toSymbol(session)
}
fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParameter): ConeKotlinType {
fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParameter, session: FirSession): ConeKotlinType {
val name = parameter.name
if (name == null || name == SpecialNames.NO_NAME_PROVIDED || name == SpecialNames.UNDERSCORE_FOR_UNUSED_VAR) return this
// Existing @ParameterName annotation takes precedence
if (attributes.customAnnotations.getAnnotationsByClassId(StandardNames.FqNames.parameterNameClassId).isNotEmpty()) return this
if (attributes.customAnnotations.getAnnotationsByClassId(StandardNames.FqNames.parameterNameClassId, session).isNotEmpty()) return this
val fakeSource = parameter.source?.fakeElement(KtFakeSourceElementKind.ParameterNameAnnotationCall)
val parameterNameAnnotationCall = buildAnnotation {
compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/calls/Synthetics.kt
+1 -2
View File
@@ -6,7 +6,6 @@
package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty
import org.jetbrains.kotlin.fir.declarations.utils.isStatic
@@ -138,7 +137,7 @@ class FirSyntheticPropertiesScope private constructor(
)
delegateGetter = getter
delegateSetter = matchingSetter
deprecationsProvider = getDeprecationsProviderFromAccessors(getter, matchingSetter, session.firCachesFactory)
deprecationsProvider = getDeprecationsProviderFromAccessors(session, getter, matchingSetter)
}
val syntheticSymbol = property.symbol
(baseScope as? FirUnstableSmartcastTypeScope)?.apply {
compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/providers/FirSymbolProvider.kt
+4 -1
View File
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.providers
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.FirSessionComponent
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors
@@ -16,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType
import org.jetbrains.kotlin.fir.types.ConeSimpleKotlinType
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.name.ClassId
@@ -78,7 +80,8 @@ fun FirSymbolProvider.getClassDeclaredPropertySymbols(classId: ClassId, name: Na
}
inline fun <reified T : FirBasedSymbol<*>> FirSymbolProvider.getSymbolByTypeRef(typeRef: FirTypeRef): T? {
val lookupTag = typeRef.coneTypeSafe<ConeLookupTagBasedType>()?.lookupTag ?: return null
val lookupTag = (typeRef.coneTypeSafe<ConeSimpleKotlinType>()?.fullyExpandedType(session) as? ConeLookupTagBasedType)?.lookupTag
?: return null
return getSymbolByLookupTag(lookupTag) as? T
}
compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirFakeOverrideGenerator.kt
+1 -2
View File
@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.scopes.impl
import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.*
import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
@@ -566,7 +565,7 @@ object FirFakeOverrideGenerator {
delegateGetter = getter
delegateSetter = setter
status = baseProperty.status
deprecationsProvider = getDeprecationsProviderFromAccessors(getter, setter, session.firCachesFactory)
deprecationsProvider = getDeprecationsProviderFromAccessors(session, getter, setter)
}.apply {
containingClassForStaticMemberAttr = derivedClassLookupTag.takeIf { shouldOverrideSetContainingClass(baseProperty) }
}.symbol
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt
+4 -3
View File
@@ -401,7 +401,7 @@ object CheckDslScopeViolation : ResolutionStage() {
val annotationClass =
annotation.annotationTypeRef.coneType.fullyExpandedType(context.session).toSymbol(context.session) as? FirClassSymbol
?: continue
if (annotationClass.hasAnnotation(dslMarkerClassId)) {
if (annotationClass.hasAnnotation(dslMarkerClassId, context.session)) {
add(annotationClass.classId)
}
}
@@ -608,7 +608,7 @@ internal object PostponedVariablesInitializerResolutionStage : ResolutionStage()
// TODO: convert type argument mapping to map [FirTypeParameterSymbol, FirTypedProjection?]
if (candidate.typeArgumentMapping is TypeArgumentMapping.Mapped) return
for (parameter in argumentMapping.values) {
if (!parameter.hasBuilderInferenceAnnotation()) continue
if (!parameter.hasBuilderInferenceAnnotation(context.session)) continue
val type = parameter.returnTypeRef.coneType
val receiverType = type.receiverType(callInfo.session) ?: continue
val dontUseBuilderInferenceIfPossible =
@@ -665,7 +665,8 @@ internal object ProcessDynamicExtensionAnnotation : ResolutionStage() {
val argumentIsDynamic = extensionReceiver.type is ConeDynamicType
val parameterIsDynamic = (candidate.symbol as? FirCallableSymbol)?.resolvedReceiverTypeRef?.type is ConeDynamicType
if (parameterIsDynamic != argumentIsDynamic ||
parameterIsDynamic && !candidate.symbol.hasAnnotation(DYNAMIC_EXTENSION_ANNOTATION_CLASS_ID)) {
parameterIsDynamic && !candidate.symbol.hasAnnotation(DYNAMIC_EXTENSION_ANNOTATION_CLASS_ID, context.session)
) {
candidate.addDiagnostic(HiddenCandidate)
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/tower/TowerLevels.kt
+1 -1
View File
@@ -391,7 +391,7 @@ class ScopeTowerLevel(
processor: TowerScopeLevelProcessor<T>
) {
val candidateReceiverTypeRef = candidate.fir.receiverParameter?.typeRef
if (withHideMembersOnly && candidate.getAnnotationByClassId(HidesMembers) == null) {
if (withHideMembersOnly && candidate.getAnnotationByClassId(HidesMembers, session) == null) {
return
}
val receiverExpected = withHideMembersOnly || areThereExtensionReceiverOptions()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirBuilderInferenceSession.kt
+5 -2
View File
@@ -6,6 +6,7 @@
package org.jetbrains.kotlin.fir.resolve.inference
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.hasAnnotation
@@ -35,6 +36,7 @@ class FirBuilderInferenceSession(
resolutionContext: ResolutionContext,
private val stubsForPostponedVariables: Map<ConeTypeVariable, ConeStubType>,
) : FirInferenceSessionForChainedResolve(resolutionContext) {
private val session = resolutionContext.session
private val commonCalls: MutableList<Pair<FirStatement, Candidate>> = mutableListOf()
private var lambdaImplicitReceivers: MutableList<ImplicitExtensionReceiverValue> = mutableListOf()
@@ -72,7 +74,7 @@ class FirBuilderInferenceSession(
return when {
extensionReceiver == null && dispatchReceiver == null -> false
dispatchReceiver?.type?.containsStubType() == true -> true
extensionReceiver?.type?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation()
extensionReceiver?.type?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation(session)
else -> false
}
}
@@ -272,4 +274,5 @@ class FirStubTypeTransformer(
private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID: ClassId = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME)
fun FirDeclaration.hasBuilderInferenceAnnotation(): Boolean = hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID)
fun FirDeclaration.hasBuilderInferenceAnnotation(session: FirSession): Boolean =
hasAnnotation(BUILDER_INFERENCE_ANNOTATION_CLASS_ID, session)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt
+1 -1
View File
@@ -467,7 +467,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
val parameters =
typeRef.contextReceiverTypeRefs.map { it.coneType } +
listOfNotNull(typeRef.receiverTypeRef?.coneType) +
typeRef.parameters.map { it.returnTypeRef.coneType.withParameterNameAnnotation(it) } +
typeRef.parameters.map { it.returnTypeRef.coneType.withParameterNameAnnotation(it, session) } +
listOf(typeRef.returnTypeRef.coneType)
val classId = if (typeRef.isSuspend) {
StandardClassIds.SuspendFunctionN(typeRef.parametersCount)
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt
+1 -2
View File
@@ -6,7 +6,6 @@
package org.jetbrains.kotlin.fir.resolve.transformers
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -488,7 +487,7 @@ abstract class AbstractFirStatusResolveTransformer(
private fun calculateDeprecations(simpleFunction: FirCallableDeclaration) {
if (simpleFunction.deprecationsProvider is UnresolvedDeprecationProvider) {
simpleFunction.replaceDeprecationsProvider(simpleFunction.getDeprecationsProvider(session.firCachesFactory))
simpleFunction.replaceDeprecationsProvider(simpleFunction.getDeprecationsProvider(session))
}
}
}
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt
+3 -2
View File
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.PrivateForInline
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -194,7 +193,9 @@ internal abstract class AbstractFirSpecificAnnotationResolveTransformer(
private fun calculateDeprecations(classLikeDeclaration: FirClassLikeDeclaration) {
if (classLikeDeclaration.deprecationsProvider == UnresolvedDeprecationProvider) {
classLikeDeclaration.replaceDeprecationsProvider(classLikeDeclaration.getDeprecationsProvider(session.firCachesFactory))
classLikeDeclaration.replaceDeprecationsProvider(
classLikeDeclaration.getDeprecationsProvider(session)
)
}
}
compiler/testData/codegen/box/annotations/jvmAnnotationFlags.kt
Vendored
-3
View File
@@ -1,8 +1,5 @@
// TARGET_BACKEND: JVM
// due to KT-55615
// IGNORE_BACKEND_K2: JVM_IR
// WITH_STDLIB
// FULL_JDK
compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.fir.kt
Vendored
-35
View File
@@ -1,35 +0,0 @@
// !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER
import kotlin.jvm.Volatile as JvmVolatile
import kotlin.concurrent.Volatile
import kotlin.properties.Delegates
@OptIn(ExperimentalStdlibApi::class)
class ConcurrentVolatile {
@Volatile val x = 0
// ok
@Volatile var y = 1
@delegate:Volatile var z: String by Delegates.observable("?") { prop, old, new -> old.hashCode() }
@field:Volatile val w = 2
@Volatile
var noBacking: String
get() = ""
set(value) {}
}
class JvmVolatile {
<!VOLATILE_ON_VALUE!>@JvmVolatile<!> val x = 0
// ok
@JvmVolatile var y = 1
<!VOLATILE_ON_DELEGATE!>@delegate:JvmVolatile<!> var z: String by Delegates.observable("?") { prop, old, new -> old.hashCode() }
<!VOLATILE_ON_VALUE!>@field:JvmVolatile<!> val w = 2
<!WRONG_ANNOTATION_TARGET!>@JvmVolatile<!>
var noBacking: String
get() = ""
set(value) {}
}
compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER
import kotlin.jvm.Volatile as JvmVolatile
import kotlin.concurrent.Volatile
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)
}
}