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 { 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)) return Name.identifier(getJvmNameAsString(property, isSetter))
} }
private fun getJvmNameAsString(property: FirProperty, isSetter: Boolean): String { private fun getJvmNameAsString(property: FirProperty, isSetter: Boolean): String {
val useSiteTarget = if (isSetter) AnnotationUseSiteTarget.PROPERTY_SETTER else AnnotationUseSiteTarget.PROPERTY_GETTER 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) { if (jvmNameFromProperty != null) {
return jvmNameFromProperty return jvmNameFromProperty
} }
val accessor = if (isSetter) property.setter else property.getter val accessor = if (isSetter) property.setter else property.getter
val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation() val jvmNameFromAccessor = accessor?.getJvmNameFromAnnotation(analysisSession.useSiteSession)
if (jvmNameFromAccessor != null) { if (jvmNameFromAccessor != null) {
return jvmNameFromAccessor 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 return true
} }
@Suppress("IntroduceWhenSubject")
return when { return when {
structureElementDeclaration !is FirRegularClass -> true structureElementDeclaration !is FirRegularClass -> true
structureElementDeclaration == declaration -> true structureElementDeclaration == declaration -> true
declaration.hasAnnotation(StandardClassIds.Annotations.Suppress) -> { declaration.hasAnnotation(StandardClassIds.Annotations.Suppress, context.session) -> {
useRegularComponents = false useRegularComponents = false
true 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.config.JvmDefaultMode
import org.jetbrains.kotlin.fir.FirAnnotationContainer 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.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.name.StandardClassIds 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 // 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 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.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors 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.analysis.jvm.checkers.isJvm6
import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.containingClassLookupTag
import org.jetbrains.kotlin.fir.declarations.* 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() { object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val jvmDefaultMode = context.session.jvmDefaultModeState 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) { if (defaultAnnotation != null) {
val containingDeclaration = context.findClosest<FirClassLikeDeclaration>() val containingDeclaration = context.findClosest<FirClassLikeDeclaration>()
@@ -53,7 +53,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
} }
} }
} else { } 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) { if (annotationNoCompatibility != null) {
val source = annotationNoCompatibility.source val source = annotationNoCompatibility.source
when { 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) { if (annotationWithCompatibility != null) {
val source = annotationWithCompatibility.source val source = annotationWithCompatibility.source
when { when {
@@ -121,7 +121,7 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
unsubstitutedScope.processFunctionsByName(member.name) {} unsubstitutedScope.processFunctionsByName(member.name) {}
val overriddenFunctions = unsubstitutedScope.getDirectOverriddenFunctions(member.symbol) 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) reporter.reportOn(declaration.source, FirJvmErrors.JVM_DEFAULT_REQUIRED_FOR_OVERRIDE, context)
} else if (jvmDefaultMode.isEnabled) { } else if (jvmDefaultMode.isEnabled) {
for (overriddenFunction in overriddenFunctions) { for (overriddenFunction in overriddenFunctions) {
@@ -147,9 +147,4 @@ object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
ArrayList<FirCallableSymbol<*>>(1).also { it.add(this) } 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() { object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) ?: return
val session = context.session val session = context.session
val annotation = declaration.getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID, session) ?: return
val containingClassSymbol = declaration.containingClassLookupTag()?.toFirRegularClassSymbol(session) val containingClassSymbol = declaration.containingClassLookupTag()?.toFirRegularClassSymbol(session)
val problem = when { val problem = when {
@@ -57,7 +57,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
if (!session.languageVersionSettings.supportsFeature(LanguageFeature.JvmFieldInInterface)) { if (!session.languageVersionSettings.supportsFeature(LanguageFeature.JvmFieldInInterface)) {
INSIDE_COMPANION_OF_INTERFACE INSIDE_COMPANION_OF_INTERFACE
} else { } else {
if (!isInterfaceCompanionWithPublicJvmFieldProperties(containingClassSymbol)) { if (!isInterfaceCompanionWithPublicJvmFieldProperties(containingClassSymbol, session)) {
NOT_PUBLIC_VAL_WITH_JVMFIELD NOT_PUBLIC_VAL_WITH_JVMFIELD
} else { } else {
return return
@@ -110,7 +110,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
return outerClassKind == ClassKind.INTERFACE || outerClassKind == ClassKind.ANNOTATION_CLASS 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) { for (symbol in containingClass.declarationSymbols) {
if (symbol !is FirPropertySymbol) continue if (symbol !is FirPropertySymbol) continue
@@ -118,7 +118,7 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
return false return false
} }
if (!symbol.hasJvmFieldAnnotation()) { if (!symbol.hasJvmFieldAnnotation(session)) {
return false return false
} }
} }
@@ -126,8 +126,8 @@ object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
return true return true
} }
private fun FirPropertySymbol.hasJvmFieldAnnotation(): Boolean { private fun FirPropertySymbol.hasJvmFieldAnnotation(session: FirSession): Boolean {
return getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID) != null return getAnnotationByClassId(JVM_FIELD_ANNOTATION_CLASS_ID, session) != null
} }
private fun isInsideJvmMultifileClassFile(context: CheckerContext): Boolean { 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() { object FirJvmInlineApplicabilityChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { 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) { if (annotation != null && !declaration.isInline) {
reporter.reportOn(annotation.source, FirJvmErrors.JVM_INLINE_WITHOUT_VALUE_CLASS, context) reporter.reportOn(annotation.source, FirJvmErrors.JVM_INLINE_WITHOUT_VALUE_CLASS, context)
} else if (annotation == null && declaration.isInline && !declaration.isExpect) { } 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.classId
import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.coneTypeSafe 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.JvmNames.JVM_RECORD_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.StandardClassIds 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 val languageVersionSettings = context.session.languageVersionSettings
if (!languageVersionSettings.supportsFeature(LanguageFeature.JvmRecordSupport)) { 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) { fun checkIfAnnotated(it: FirDeclaration) {
if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic)) { if (!it.hasAnnotation(StandardClassIds.Annotations.JvmStatic, context.session)) {
return return
} }
val targetSource = it.source ?: declaration.source 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() { object FirJvmSyntheticApplicabilityChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { 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) { if (annotation != null && annotation.useSiteTarget == AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD) {
reporter.reportOn(annotation.source, FirJvmErrors.JVM_SYNTHETIC_ON_DELEGATE, context) 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() { object FirOverloadsChecker : FirFunctionChecker() {
override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) { 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 //todo need to have expect declaration here to check if it has default values
if (declaration.isActual) return if (declaration.isActual) return
val containingDeclaration = declaration.getContainingClassSymbol(context.session) val containingDeclaration = declaration.getContainingClassSymbol(session)
when { when {
containingDeclaration?.classKind == ClassKind.INTERFACE -> containingDeclaration?.classKind == ClassKind.INTERFACE ->
reporter.reportOn(annotation.source, FirJvmErrors.OVERLOADS_INTERFACE, context) 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.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.diagnostics.reportOn 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.containsRepeatableAnnotation
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext 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.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationRetention import org.jetbrains.kotlin.fir.analysis.checkers.getAnnotationRetention
import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope 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.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6 import org.jetbrains.kotlin.fir.analysis.jvm.checkers.isJvm6
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
@@ -48,7 +48,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
val session = context.session val session = context.session
for (annotation in annotations) { for (annotation in annotations) {
val classId = annotation.classId ?: continue val classId = annotation.classId ?: continue
val annotationClassId = annotation.toAnnotationClassId() ?: continue val annotationClassId = annotation.toAnnotationClassId(session) ?: continue
if (annotationClassId.isLocal) continue if (annotationClassId.isLocal) continue
val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: continue val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: continue
@@ -60,7 +60,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
if (duplicateAnnotation && if (duplicateAnnotation &&
annotationClass.containsRepeatableAnnotation(session) && annotationClass.containsRepeatableAnnotation(session) &&
annotationClass.getAnnotationRetention() != AnnotationRetention.SOURCE annotationClass.getAnnotationRetention(session) != AnnotationRetention.SOURCE
) { ) {
if (context.isJvm6()) { if (context.isJvm6()) {
reporter.reportOn(annotation.source, FirJvmErrors.REPEATED_ANNOTATION_TARGET6, context) 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 // It's not allowed to have both a repeated annotation (applied more than once) and its container
// on the same element. // on the same element.
// See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.7.5. // 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 }) { if (explicitContainer != null && annotations.any { it.classId == explicitContainer }) {
reporter.reportOn( reporter.reportOn(
annotation.source, annotation.source,
@@ -99,9 +99,9 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
} }
} }
private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(): ClassId? { private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(session: FirSession): ClassId? {
val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable) val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session)
?: getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable) ?: getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable, session)
?: return null ?: return null
return repeatableAnnotation.resolveContainerAnnotation() return repeatableAnnotation.resolveContainerAnnotation()
} }
@@ -202,8 +202,8 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
) { ) {
val annotationRetention = annotationClass.symbol.getAnnotationRetention() val annotationRetention = annotationClass.symbol.getAnnotationRetention(context.session)
val containerRetention = containerClass.getAnnotationRetention() val containerRetention = containerClass.getAnnotationRetention(context.session)
if (containerRetention < annotationRetention) { if (containerRetention < annotationRetention) {
reporter.reportOn( reporter.reportOn(
annotationSource, annotationSource,
@@ -224,8 +224,8 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
context: CheckerContext, context: CheckerContext,
reporter: DiagnosticReporter reporter: DiagnosticReporter
) { ) {
val annotationTargets = annotationClass.getAllowedAnnotationTargets() val annotationTargets = annotationClass.getAllowedAnnotationTargets(context.session)
val containerTargets = containerClass.getAllowedAnnotationTargets() val containerTargets = containerClass.getAllowedAnnotationTargets(context.session)
// See https://docs.oracle.com/javase/specs/jls/se16/html/jls-9.html#jls-9.6.3. // 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 // (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() { object FirStrictfpApplicabilityChecker : FirClassChecker() {
override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) { 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) 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 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.descriptors.ClassKind
import org.jetbrains.kotlin.fir.analysis.checkers.classKind import org.jetbrains.kotlin.fir.analysis.checkers.classKind
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext 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() { object FirSynchronizedAnnotationChecker : FirFunctionChecker() {
override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) { 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) { if (declaration.isInline) {
reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_INLINE, context) reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_INLINE, context)
return return
} }
if (declaration.isSuspend || 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) reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_ON_SUSPEND, context)
return return
} }
val containingClass = declaration.getContainingClassSymbol(context.session) ?: return val containingClass = declaration.getContainingClassSymbol(session) ?: return
if (containingClass.classKind == ClassKind.INTERFACE) { if (containingClass.classKind == ClassKind.INTERFACE) {
reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_IN_INTERFACE, context) reporter.reportOn(annotation.source, FirJvmErrors.SYNCHRONIZED_IN_INTERFACE, context)
} else if (declaration.isAbstract) { } 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) { override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration.source?.kind != KtRealSourceElementKind) return 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) { if (fieldAnnotation != null && !declaration.isVar) {
reporter.reportOn(fieldAnnotation.source, FirJvmErrors.VOLATILE_ON_VALUE, context) 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) { if (delegateAnnotation != null) {
reporter.reportOn(delegateAnnotation.source, FirJvmErrors.VOLATILE_ON_DELEGATE, context) 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 val classId = symbol?.callableId?.classId ?: return
if (classId.isLocal) return if (classId.isLocal) return
val session = context.session
fun getTypeSymbol(): FirRegularClassSymbol? { fun getTypeSymbol(): FirRegularClassSymbol? {
return context.session.symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol return session.symbolProvider.getClassLikeSymbolByClassId(classId) as? FirRegularClassSymbol
} }
val supportsDefaults = !context.isJvm6() val supportsDefaults = !context.isJvm6()
@@ -49,11 +50,13 @@ object FirInterfaceDefaultMethodCallChecker : FirQualifiedAccessExpressionChecke
if (typeSymbol == null) typeSymbol = getTypeSymbol() ?: return if (typeSymbol == null) typeSymbol = getTypeSymbol() ?: return
val jvmDefaultMode = context.session.jvmDefaultModeState val jvmDefaultMode = session.jvmDefaultModeState
if (typeSymbol.isInterface && (typeSymbol.origin is FirDeclarationOrigin.Java || symbol.isCompiledToJvmDefault(jvmDefaultMode))) { if (typeSymbol.isInterface &&
(typeSymbol.origin is FirDeclarationOrigin.Java || symbol.isCompiledToJvmDefault(session, jvmDefaultMode))
) {
if (containingDeclaration.isInterface) { if (containingDeclaration.isInterface) {
val containingMember = context.findContainingMember()?.symbol 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) reporter.reportOn(expression.source, FirJvmErrors.INTERFACE_CANT_CALL_DEFAULT_METHOD_VIA_SUPER, context)
return 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) { override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
if (!context.session.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature)) return if (!context.session.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature)) return
val callableSymbol = expression.calleeReference.toResolvedCallableSymbol() ?: 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) { for (valueArgument in expression.arguments) {
if (valueArgument is FirVarargArgumentsExpression) { 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 resolvedSymbol.visibility
} }
if (visibility != Visibilities.Protected) return 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 if (!dispatchClassSymbol.isCompanion) return
val companionContainingClassSymbol = val companionContainingClassSymbol =
dispatchClassSymbol.getContainingDeclarationSymbol(context.session) as? FirRegularClassSymbol ?: return 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 import org.jetbrains.kotlin.name.ClassId
fun DiagnosticReporter.reportIfHasAnnotation( fun DiagnosticReporter.reportIfHasAnnotation(
declaration: FirDeclaration, declaration: FirDeclaration,
annotationClassId: ClassId, annotationClassId: ClassId,
error: KtDiagnosticFactory0, error: KtDiagnosticFactory0,
context: CheckerContext context: CheckerContext
) { ) {
val annotation = declaration.getAnnotationByClassId(annotationClassId) val annotation = declaration.getAnnotationByClassId(annotationClassId, context.session)
if (annotation != null) { if (annotation != null) {
reportOn(annotation.source, error, context) 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.DiagnosticReporter
import org.jetbrains.kotlin.diagnostics.reportOn import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.FirAnnotationContainer 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.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirBasicDeclarationChecker
import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
@@ -51,7 +52,7 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker() {
private fun checkDeclaration(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { private fun checkDeclaration(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration is FirValueParameter) return // those are checked with the FirFunction 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 (objCNames.isEmpty()) return
if (declaration is FirCallableDeclaration && declaration.isOverride) { if (declaration is FirCallableDeclaration && declaration.isOverride) {
for (objCName in objCNames) { for (objCName in objCNames) {
@@ -115,20 +116,20 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker() {
} }
} }
private fun FirAnnotationContainer.getObjCName(): ObjCName? = private fun FirAnnotationContainer.getObjCName(session: FirSession): ObjCName? =
getAnnotationByClassId(objCNameClassId)?.let(::ObjCName) getAnnotationByClassId(objCNameClassId, session)?.let(::ObjCName)
private fun FirBasedSymbol<*>.getObjCName(): ObjCName? = private fun FirBasedSymbol<*>.getObjCName(session: FirSession): ObjCName? =
getAnnotationByClassId(objCNameClassId)?.let(::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 { is FirFunctionSymbol<*> -> buildList {
add((this@getObjCNames as FirBasedSymbol<*>).getObjCName()) add((this@getObjCNames as FirBasedSymbol<*>).getObjCName(session))
add(resolvedReceiverTypeRef?.getObjCName()) add(resolvedReceiverTypeRef?.getObjCName(session))
add(receiverParameter?.getObjCName()) add(receiverParameter?.getObjCName(session))
valueParameterSymbols.forEach { add(it.getObjCName()) } 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) val overriddenSymbols = firTypeScope.retrieveDirectOverriddenOf(memberSymbol)
if (overriddenSymbols.isEmpty()) return 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()) { if (!objCNames.allNamesEquals()) {
val containingDeclarations = overriddenSymbols.mapNotNull { it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session) } val containingDeclarations = overriddenSymbols.mapNotNull {
it.containingClassLookupTag()?.toFirRegularClassSymbol(context.session)
}
reporter.reportOn( reporter.reportOn(
declarationToReport.source, declarationToReport.source,
INCOMPATIBLE_OBJC_NAME_OVERRIDE, 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.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.diagnostics.reportOn 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.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirRegularClassChecker
import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets import org.jetbrains.kotlin.fir.analysis.checkers.getAllowedAnnotationTargets
@@ -24,7 +25,8 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return 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) return
if (objCAnnotation != null && swiftAnnotation != null) { if (objCAnnotation != null && swiftAnnotation != null) {
reporter.reportOn( reporter.reportOn(
@@ -33,7 +35,7 @@ object FirNativeObjCRefinementAnnotationChecker : FirRegularClassChecker() {
context context
) )
} }
val targets = declaration.getAllowedAnnotationTargets() val targets = declaration.getAllowedAnnotationTargets(session)
val unsupportedTargets = targets - supportedTargets val unsupportedTargets = targets - supportedTargets
if (unsupportedTargets.isNotEmpty()) { if (unsupportedTargets.isNotEmpty()) {
objCAnnotation?.let { reporter.reportOn(it.source, FirNativeErrors.INVALID_OBJC_REFINEMENT_TARGETS, context) } 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 objCAnnotation: FirAnnotation? = null
var swiftAnnotation: FirAnnotation? = null var swiftAnnotation: FirAnnotation? = null
for (annotation in annotations) { for (annotation in annotations) {
when (annotation.toAnnotationClassId()) { when (annotation.toAnnotationClassId(session)) {
hidesFromObjCClassId -> objCAnnotation = annotation hidesFromObjCClassId -> objCAnnotation = annotation
refinesInSwiftClassId -> swiftAnnotation = 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) { for (annotation in annotations) {
val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty() val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty()
for (metaAnnotation in metaAnnotations) { for (metaAnnotation in metaAnnotations) {
when (metaAnnotation.toAnnotationClassId()) { when (metaAnnotation.toAnnotationClassId(session)) {
hidesFromObjCClassId -> { hidesFromObjCClassId -> {
objCAnnotations.add(annotation) objCAnnotations.add(annotation)
break 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) { for (annotation in resolvedAnnotationsWithClassIds) {
val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty() val metaAnnotations = annotation.coneClassLikeType?.lookupTag?.toSymbol(session)?.resolvedAnnotationsWithClassIds.orEmpty()
for (metaAnnotation in metaAnnotations) { for (metaAnnotation in metaAnnotations) {
when (metaAnnotation.toAnnotationClassId()) { when (metaAnnotation.toAnnotationClassId(session)) {
hidesFromObjCClassId -> { hidesFromObjCClassId -> {
hasObjC = true hasObjC = true
break 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) { 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 if (!checkInheritance(declaration, throwsAnnotation, context, reporter)) return
@@ -123,7 +123,7 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
val annotation = if (overriddenFunction.isSubstitutionOrIntersectionOverride) { val annotation = if (overriddenFunction.isSubstitutionOrIntersectionOverride) {
null null
} else { } else {
overriddenFunction.getAnnotationByClassId(throwsClassId) as? FirAnnotationCall overriddenFunction.getAnnotationByClassId(throwsClassId, context.session) as? FirAnnotationCall
} }
getInheritedThrows(annotation, overriddenFunction) 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.UseSiteTargetsList
import org.jetbrains.kotlin.resolve.checkers.OptInNames import org.jetbrains.kotlin.resolve.checkers.OptInNames
fun FirRegularClass.getRetention(): AnnotationRetention { fun FirRegularClass.getRetention(session: FirSession): AnnotationRetention {
return getRetentionAnnotation()?.getRetention() ?: AnnotationRetention.RUNTIME return getRetentionAnnotation(session)?.getRetention() ?: AnnotationRetention.RUNTIME
} }
fun FirAnnotation.getRetention(): AnnotationRetention { fun FirAnnotation.getRetention(): AnnotationRetention {
@@ -51,24 +51,24 @@ fun FirAnnotation.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTa
val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType) val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType)
?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets ?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets
annotationClassSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) annotationClassSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
return annotationClassSymbol.getAllowedAnnotationTargets() return annotationClassSymbol.getAllowedAnnotationTargets(session)
} }
internal fun FirAnnotation.getAnnotationClassForOptInMarker(session: FirSession): FirRegularClassSymbol? { internal fun FirAnnotation.getAnnotationClassForOptInMarker(session: FirSession): FirRegularClassSymbol? {
val lookupTag = annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return null val lookupTag = annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag ?: return null
val annotationClassSymbol = lookupTag.toSymbol(session) as? FirRegularClassSymbol ?: 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 null
} }
return annotationClassSymbol return annotationClassSymbol
} }
fun FirRegularClass.getAllowedAnnotationTargets(): Set<KotlinTarget> { fun FirRegularClass.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTarget> {
return symbol.getAllowedAnnotationTargets() return symbol.getAllowedAnnotationTargets(session)
} }
fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set<KotlinTarget> { fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTarget> {
val targetAnnotation = getTargetAnnotation() ?: return defaultAnnotationTargets val targetAnnotation = getTargetAnnotation(session) ?: return defaultAnnotationTargets
val arguments = targetAnnotation.findArgumentByName(ParameterNames.targetAllowedTargets)?.unfoldArrayOrVararg().orEmpty() val arguments = targetAnnotation.findArgumentByName(ParameterNames.targetAllowedTargets)?.unfoldArrayOrVararg().orEmpty()
return arguments.mapNotNullTo(mutableSetOf()) { argument -> return arguments.mapNotNullTo(mutableSetOf()) { argument ->
@@ -78,16 +78,16 @@ fun FirClassLikeSymbol<*>.getAllowedAnnotationTargets(): Set<KotlinTarget> {
} }
} }
fun FirDeclaration.getRetentionAnnotation(): FirAnnotation? { fun FirDeclaration.getRetentionAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Retention) return getAnnotationByClassId(StandardClassIds.Annotations.Retention, session)
} }
fun FirDeclaration.getTargetAnnotation(): FirAnnotation? { fun FirDeclaration.getTargetAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Target) return getAnnotationByClassId(StandardClassIds.Annotations.Target, session)
} }
fun FirClassLikeSymbol<*>.getTargetAnnotation(): FirAnnotation? { fun FirClassLikeSymbol<*>.getTargetAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(StandardClassIds.Annotations.Target) return getAnnotationByClassId(StandardClassIds.Annotations.Target, session)
} }
fun FirExpression.extractClassesFromArgument(session: FirSession): List<FirRegularClassSymbol> { fun FirExpression.extractClassesFromArgument(session: FirSession): List<FirRegularClassSymbol> {
@@ -123,7 +123,7 @@ fun checkRepeatedAnnotation(
} }
fun FirAnnotation.isRepeatable(session: FirSession): Boolean { fun FirAnnotation.isRepeatable(session: FirSession): Boolean {
val annotationClassId = this.toAnnotationClassId() ?: return false val annotationClassId = this.toAnnotationClassId(session) ?: return false
if (annotationClassId.isLocal) return false if (annotationClassId.isLocal) return false
val annotationClass = session.symbolProvider.getClassLikeSymbolByClassId(annotationClassId) ?: 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 { fun FirClassLikeSymbol<*>.containsRepeatableAnnotation(session: FirSession): Boolean {
if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable) != null) return true if (getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session) != null) return true
if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable) != null || if (getAnnotationByClassId(StandardClassIds.Annotations.Java.Repeatable, session) != null ||
getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable) != null getAnnotationByClassId(StandardClassIds.Annotations.JvmRepeatable, session) != null
) { ) {
return session.languageVersionSettings.supportsFeature(LanguageFeature.RepeatableAnnotations) || return session.languageVersionSettings.supportsFeature(LanguageFeature.RepeatableAnnotations) ||
getAnnotationRetention() == AnnotationRetention.SOURCE && origin is FirDeclarationOrigin.Java getAnnotationRetention(session) == AnnotationRetention.SOURCE && origin is FirDeclarationOrigin.Java
} }
return false return false
} }
fun FirClassLikeSymbol<*>.getAnnotationRetention(): AnnotationRetention { fun FirClassLikeSymbol<*>.getAnnotationRetention(session: FirSession): AnnotationRetention {
return getAnnotationByClassId(StandardClassIds.Annotations.Retention)?.getRetention() ?: AnnotationRetention.RUNTIME return getAnnotationByClassId(StandardClassIds.Annotations.Retention, session)?.getRetention() ?: AnnotationRetention.RUNTIME
} }
fun FirAnnotationContainer.getDefaultUseSiteTarget( 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.*
import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference 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.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -126,7 +125,9 @@ internal fun checkConstantArguments(
val symbol = calleeReference.resolvedSymbol as? FirNamedFunctionSymbol ?: return ConstantArgumentKind.NOT_CONST val symbol = calleeReference.resolvedSymbol as? FirNamedFunctionSymbol ?: return ConstantArgumentKind.NOT_CONST
@OptIn(SymbolInternals::class) @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)) { for (exp in expression.arguments.plus(expression.dispatchReceiver).plus(expression.extensionReceiver)) {
if (exp is FirNoReceiverExpression) continue if (exp is FirNoReceiverExpression) continue
@@ -152,7 +153,7 @@ internal fun checkConstantArguments(
@OptIn(SymbolInternals::class) @OptIn(SymbolInternals::class)
val property = propertySymbol.fir val property = propertySymbol.fir
when { when {
property.unwrapFakeOverrides().getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION) != null -> { property.unwrapFakeOverrides().getAnnotationByClassId(INTRINSIC_CONST_EVALUATION_ANNOTATION, session) != null -> {
return checkConstantArguments(expression.dispatchReceiver, session) return checkConstantArguments(expression.dispatchReceiver, session)
} }
propertySymbol.isLocal || propertySymbol.callableId.className?.isRoot == false -> return ConstantArgumentKind.NOT_CONST 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 = fun KotlinTypeMarker.isSupertypeOf(context: TypeCheckerProviderContext, type: KotlinTypeMarker?): Boolean =
type != null && AbstractTypeChecker.isSubtypeOf(context, type, this) type != null && AbstractTypeChecker.isSubtypeOf(context, type, this)
fun FirMemberDeclaration.isInlineOnly(): Boolean = fun FirMemberDeclaration.isInlineOnly(session: FirSession): Boolean =
isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID) isInline && hasAnnotation(INLINE_ONLY_ANNOTATION_CLASS_ID, session)
fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean { fun isSubtypeForTypeMismatch(context: ConeInferenceContext, subtype: ConeKotlinType, supertype: ConeKotlinType): Boolean {
val subtypeFullyExpanded = subtype.fullyExpandedType(context.session) 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 // TODO: use-site targeted annotations
fun FirDeclaration.consider() { 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) val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
if (apiVersion != null) { if (apiVersion != null) {
// TODO: combine wasExperimentalMarkerClasses in case of several associated declarations with the same maximal API version // 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> { 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() val annotationClasses = wasExperimental.findArgumentByName(OptInNames.WAS_EXPERIMENTAL_ANNOTATION_CLASS) ?: return emptyList()
return annotationClasses.extractClassesFromArgument(session) 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) checkAnnotationClassMember(member, context, reporter)
} }
if (declaration.getRetention() != AnnotationRetention.SOURCE && val session = context.session
KotlinTarget.EXPRESSION in declaration.getAllowedAnnotationTargets() 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) 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) { private fun checkNothingToInline(function: FirSimpleFunction, context: CheckerContext, reporter: DiagnosticReporter) {
if (function.isExpect || function.isSuspend) return if (function.isExpect || function.isSuspend) return
if (function.typeParameters.any { it.symbol.isReified }) return if (function.typeParameters.any { it.symbol.isReified }) return
val session = context.session
val hasInlinableParameters = val hasInlinableParameters =
function.valueParameters.any { param -> function.valueParameters.any { param ->
val type = param.returnTypeRef.coneType val type = param.returnTypeRef.coneType
!param.isNoinline && !type.isNullable !param.isNoinline && !type.isNullable
&& (type.isFunctionalType(context.session) || type.isSuspendFunctionType(context.session)) && (type.isFunctionalType(session) || type.isSuspendFunctionType(session))
} }
if (hasInlinableParameters) return if (hasInlinableParameters) return
if (function.isInlineOnly()) return if (function.isInlineOnly(session)) return
if (function.returnTypeRef.needsMultiFieldValueClassFlattening(context.session)) return if (function.returnTypeRef.needsMultiFieldValueClassFlattening(session)) return
reporter.reportOn(function.source, FirErrors.NOTHING_TO_INLINE, context) 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() { object FirOptInAnnotationClassChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) { override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return if (declaration.classKind != ClassKind.ANNOTATION_CLASS) return
if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) == null) return val session = context.session
if (declaration.getRetention() == AnnotationRetention.SOURCE) { if (declaration.getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session) == null) return
val target = declaration.getRetentionAnnotation() if (declaration.getRetention(session) == AnnotationRetention.SOURCE) {
val target = declaration.getRetentionAnnotation(session)
reporter.reportOn(target?.source, FirErrors.OPT_IN_MARKER_WITH_WRONG_RETENTION, context) 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()) { if (wrongTargets.isNotEmpty()) {
val target = declaration.getTargetAnnotation() val target = declaration.getTargetAnnotation(session)
reporter.reportOn( reporter.reportOn(
target?.source, target?.source,
FirErrors.OPT_IN_MARKER_WITH_WRONG_TARGET, 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 || if (useSiteTarget == SETTER_PARAMETER ||
(useSiteTarget != PROPERTY && useSiteTarget != PROPERTY_SETTER && declaration is FirValueParameter && (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) 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 FirMemberDeclaration) return
if (declaration is FirValueParameter) return if (declaration is FirValueParameter) return
if (declaration.visibility == Visibilities.Internal) 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) 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) checkFinalUpperBounds(declaration, containingDeclaration, context, reporter)
checkExtensionFunctionTypeBound(declaration, context, reporter) checkExtensionFunctionTypeBound(declaration, context, reporter)
if ((containingDeclaration as? FirMemberDeclaration)?.isInlineOnly() != true) { if ((containingDeclaration as? FirMemberDeclaration)?.isInlineOnly(context.session) != true) {
checkOnlyOneTypeParameterBound(declaration, context, reporter) 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 context: CheckerContext
) { ) {
with(FirOptInUsageBaseChecker) { with(FirOptInUsageBaseChecker) {
if (classSymbol.loadExperimentalityForMarkerAnnotation() == null) { if (classSymbol.loadExperimentalityForMarkerAnnotation(context.session) == null) {
reporter.reportOn( reporter.reportOn(
source, source,
FirErrors.OPT_IN_ARGUMENT_IS_NOT_MARKER, 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 // 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) lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
@OptIn(SymbolInternals::class) @OptIn(SymbolInternals::class)
return fir.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName) return fir.loadExperimentalityForMarkerAnnotation(session, annotatedOwnerClassName)
} }
fun FirBasedSymbol<*>.loadExperimentalitiesFromAnnotationTo(session: FirSession, result: MutableCollection<Experimentality>) { fun FirBasedSymbol<*>.loadExperimentalitiesFromAnnotationTo(session: FirSession, result: MutableCollection<Experimentality>) {
@@ -90,14 +93,14 @@ object FirOptInUsageBaseChecker {
result.addIfNotNull( result.addIfNotNull(
annotationType.lookupTag.toFirRegularClassSymbol( annotationType.lookupTag.toFirRegularClassSymbol(
session session
)?.loadExperimentalityForMarkerAnnotation(className) )?.loadExperimentalityForMarkerAnnotation(session, className)
) )
if (fromSupertype) { if (fromSupertype) {
if (annotationType.lookupTag.classId == OptInNames.SUBCLASS_OPT_IN_REQUIRED_CLASS_ID) { if (annotationType.lookupTag.classId == OptInNames.SUBCLASS_OPT_IN_REQUIRED_CLASS_ID) {
val annotationClass = annotation.findArgumentByName(OptInNames.OPT_IN_ANNOTATION_CLASS) ?: continue val annotationClass = annotation.findArgumentByName(OptInNames.OPT_IN_ANNOTATION_CLASS) ?: continue
result.addIfNotNull( result.addIfNotNull(
annotationClass.extractClassFromArgument(session) annotationClass.extractClassFromArgument(session)
?.loadExperimentalityForMarkerAnnotation()?.copy(fromSupertype = true) ?.loadExperimentalityForMarkerAnnotation(session)?.copy(fromSupertype = true)
) )
} }
} }
@@ -159,12 +162,12 @@ object FirOptInUsageBaseChecker {
fir.loadExperimentalitiesFromAnnotationTo(session, result, fromSupertype) 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) val accessibility = fir.checkSinceKotlinVersionAccessibility(context)
if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) { if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) {
accessibility.markerClasses.forEach { accessibility.markerClasses.forEach {
it.lazyResolveToPhase(FirResolvePhase.STATUS) 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 // 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? { private fun FirRegularClass.loadExperimentalityForMarkerAnnotation(
val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID) session: FirSession,
annotatedOwnerClassName: String? = null
): Experimentality? {
val experimental = getAnnotationByClassId(OptInNames.REQUIRES_OPT_IN_CLASS_ID, session)
?: return null ?: return null
val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression val levelArgument = experimental.findArgumentByName(LEVEL) as? FirQualifiedAccessExpression
@@ -321,11 +327,11 @@ object FirOptInUsageBaseChecker {
annotationClassId: ClassId, annotationClassId: ClassId,
fromSupertype: Boolean fromSupertype: Boolean
): Boolean { ): Boolean {
return getAnnotationByClassId(annotationClassId) != null || isAnnotatedWithOptIn(session, annotationClassId) || return getAnnotationByClassId(annotationClassId, session) != null || isAnnotatedWithOptIn(annotationClassId, session) ||
fromSupertype && isAnnotatedWithSubclassOptInRequired(session, annotationClassId) 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) { for (annotation in annotations) {
val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType val coneType = annotation.annotationTypeRef.coneType as? ConeClassLikeType
if (coneType?.lookupTag?.classId != OptInNames.OPT_IN_CLASS_ID) { 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) { when (this) {
is ConeClassLikeType -> { is ConeClassLikeType -> {
val regularClassSymbol = fullyExpandedType(session).lookupTag.toFirRegularClassSymbol(session) ?: return false 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 true
} }
return regularClassSymbol.resolvedSuperTypes.any { it.isRestrictSuspensionReceiver(session) } 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 (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) {
if (classId == OptInNames.REQUIRES_OPT_IN_CLASS_ID || classId == OptInNames.OPT_IN_CLASS_ID) { 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) 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) 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.builtins.jvm.JvmBuiltInsSignatures
import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.* import org.jetbrains.kotlin.fir.declarations.builder.*
import org.jetbrains.kotlin.fir.declarations.comparators.FirMemberDeclarationComparator import org.jetbrains.kotlin.fir.declarations.comparators.FirMemberDeclarationComparator
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.declarations.utils.* 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.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
@@ -231,7 +229,7 @@ fun deserializeClassToSymbol(
sourceElement = containerSource sourceElement = containerSource
replaceDeprecationsProvider(getDeprecationsProvider(session.firCachesFactory)) replaceDeprecationsProvider(getDeprecationsProvider(session))
classProto.getExtensionOrNull(JvmProtoBuf.classModuleName)?.let { idx -> classProto.getExtensionOrNull(JvmProtoBuf.classModuleName)?.let { idx ->
moduleName = nameResolver.getString(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.descriptors.Modality
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.* 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.FirDefaultPropertySetter
import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
import org.jetbrains.kotlin.fir.declarations.utils.sourceElement 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.FirExpression
import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -431,7 +429,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
} }
this.containerSource = c.containerSource this.containerSource = c.containerSource
this.initializer = c.constDeserializer.loadConstant(proto, symbol.callableId, c.nameResolver) 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) proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver)
}.apply { }.apply {
@@ -514,7 +512,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
) )
annotations += annotations +=
c.annotationDeserializer.loadFunctionAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable) 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 this.containerSource = c.containerSource
proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver) proto.contextReceiverTypes(c.typeTable).mapTo(contextReceivers, ::loadContextReceiver)
@@ -594,7 +592,7 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
annotations += annotations +=
c.annotationDeserializer.loadConstructorAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable) c.annotationDeserializer.loadConstructorAnnotations(c.containerSource, proto, local.nameResolver, local.typeTable)
containerSource = c.containerSource containerSource = c.containerSource
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = false, c.session.firCachesFactory) deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(c.session, fromJava = false)
contextReceivers.addAll(createContextReceiversForClass(classProto)) contextReceivers.addAll(createContextReceiversForClass(classProto))
}.build().apply { }.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> = private fun MutableVersionRequirementTable.serializeVersionRequirements(annotations: List<FirAnnotation>): List<Int> =
annotations annotations
.filter { .filter {
it.toAnnotationClassId()?.asSingleFqName() == RequireKotlinConstants.FQ_NAME it.toAnnotationClassId(session)?.asSingleFqName() == RequireKotlinConstants.FQ_NAME
} }
.mapNotNull(::serializeVersionRequirementFromRequireKotlin) .mapNotNull(::serializeVersionRequirementFromRequireKotlin)
.map(::get) .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 { private fun FirProperty.isJvmFieldPropertyInInterfaceCompanion(): Boolean {
if (!hasJvmFieldAnnotation) return false if (!hasJvmFieldAnnotation(session)) return false
val containerSymbol = (dispatchReceiverType as? ConeClassLikeType)?.lookupTag?.toFirRegularClassSymbol(session) val containerSymbol = (dispatchReceiverType as? ConeClassLikeType)?.lookupTag?.toFirRegularClassSymbol(session)
// Note: companions are anyway forbidden in local classes // 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 hasExplicitBackingField -> backingField?.visibility ?: status.visibility
isLateInit -> setter?.visibility ?: status.visibility isLateInit -> setter?.visibility ?: status.visibility
isConst -> status.visibility isConst -> status.visibility
hasJvmFieldAnnotation -> status.visibility hasJvmFieldAnnotation(session) -> status.visibility
else -> Visibilities.Private 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 { builtIns.extensionFunctionTypeAnnotationConstructorCall()?.let {
typeAnnotations += it 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 { fun convertToIrConstructorCall(annotation: FirAnnotation): IrExpression {
val coneType = annotation.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>() val coneType = annotation.annotationTypeRef.coneTypeSafe<ConeLookupTagBasedType>()
?.fullyExpandedType(session) as? ConeLookupTagBasedType
val type = coneType?.toIrType() val type = coneType?.toIrType()
val symbol = type?.classifierOrNull val symbol = type?.classifierOrNull
return annotation.convertWithOffsets { startOffset, endOffset -> return annotation.convertWithOffsets { startOffset, endOffset ->
@@ -693,7 +694,7 @@ class CallAndReferenceGenerator(
return buildAnnotationCall { return buildAnnotationCall {
useSiteTarget = this@toAnnotationCall.useSiteTarget useSiteTarget = this@toAnnotationCall.useSiteTarget
annotationTypeRef = this@toAnnotationCall.annotationTypeRef 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 constructorSymbol = symbol.declarationSymbols.firstIsInstanceOrNull<FirConstructorSymbol>() ?: return null
val argumentToParameterToMapping = constructorSymbol.valueParameterSymbols.mapNotNull { val argumentToParameterToMapping = constructorSymbol.valueParameterSymbols.mapNotNull {
val parameter = it.fir 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 val wrappedSymbol = wrapped.symbol as? S ?: return null
@Suppress("UNCHECKED_CAST") @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 // See org.jetbrains.kotlin.resolve.jvm.JvmDelegationFilter
return (unwrapped is FirSimpleFunction && unwrapped.isDefaultJavaMethod()) || return (unwrapped is FirSimpleFunction && unwrapped.isDefaultJavaMethod()) ||
unwrapped.hasAnnotation(JVM_DEFAULT_CLASS_ID) || unwrapped.hasAnnotation(JVM_DEFAULT_CLASS_ID, session) ||
unwrapped.hasAnnotation(PLATFORM_DEPENDENT_CLASS_ID) unwrapped.hasAnnotation(PLATFORM_DEPENDENT_CLASS_ID, session)
} }
private fun FirSimpleFunction.isDefaultJavaMethod(): Boolean = 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 { private fun hasJvmStaticAnnotation(): Boolean {
return fir.hasAnnotation(JVM_STATIC_CLASS_ID) || return fir.hasAnnotation(JVM_STATIC_CLASS_ID, session) ||
(fir as? FirPropertyAccessor)?.propertySymbol?.fir?.hasAnnotation(JVM_STATIC_CLASS_ID) == true (fir as? FirPropertyAccessor)?.propertySymbol?.fir?.hasAnnotation(JVM_STATIC_CLASS_ID, session) == true
} }
protected fun createThisReceiverParameter(thisType: IrType, explicitReceiver: FirReceiverParameter? = null): IrValueParameter { 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.replaceSuperTypeRefs(enhancedSuperTypes)
firJavaClass.replaceDeprecationsProvider(firJavaClass.getDeprecationsProvider(session.firCachesFactory)) firJavaClass.replaceDeprecationsProvider(firJavaClass.getDeprecationsProvider(session))
return firJavaClass 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) private val jvmRecordUpdater = DelegatedConstructorCallTransformer(session)
override fun updateSupertypesIfNeeded(firClass: FirClass, scopeSession: ScopeSession) { 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 anyFound = false
var hasExplicitSuperClass = false var hasExplicitSuperClass = false
val newSuperTypeRefs = firClass.superTypeRefs.mapTo(mutableListOf()) { 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.FirImplementationDetail
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl 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.*
import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirFieldBuilder
import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirAnnotation
@@ -65,7 +64,7 @@ class FirJavaField @FirImplementationDetail constructor(
get() = lazyInitializer.value get() = lazyInitializer.value
override val deprecationsProvider: DeprecationsProvider by lazy { override val deprecationsProvider: DeprecationsProvider by lazy {
annotations.getDeprecationsProviderFromAnnotations(fromJava = true, moduleData.session.firCachesFactory) annotations.getDeprecationsProviderFromAnnotations(moduleData.session, fromJava = true)
} }
override val contextReceivers: List<FirContextReceiver> 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.FirSession
import org.jetbrains.kotlin.fir.ThreadSafeMutableState import org.jetbrains.kotlin.fir.ThreadSafeMutableState
import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty 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.FirDeclarationOrigin
import org.jetbrains.kotlin.fir.declarations.getDeprecationsProvider import org.jetbrains.kotlin.fir.declarations.getDeprecationsProvider
import org.jetbrains.kotlin.fir.deserialization.* import org.jetbrains.kotlin.fir.deserialization.*
@@ -158,7 +157,7 @@ class JvmClassFileBasedSymbolProvider(
kotlinClass.byteContent, kotlinClass.byteContent,
) )
symbol.fir.replaceAnnotations(annotations.toMutableOrEmpty()) 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? { 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 delegateGetter = enhancedGetterSymbol.fir as FirSimpleFunction
delegateSetter = enhancedSetterSymbol?.fir as FirSimpleFunction? delegateSetter = enhancedSetterSymbol?.fir as FirSimpleFunction?
status = firElement.status status = firElement.status
deprecationsProvider = getDeprecationsProviderFromAccessors(delegateGetter, delegateSetter, session.firCachesFactory) deprecationsProvider = getDeprecationsProviderFromAccessors(session, delegateGetter, delegateSetter)
}.symbol }.symbol
} }
else -> { else -> {
@@ -332,7 +332,7 @@ class FirSignatureEnhancement(
} }
this.valueParameters += newValueParameters this.valueParameters += newValueParameters
annotations += firMethod.annotations annotations += firMethod.annotations
deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(fromJava = true, session.firCachesFactory) deprecationsProvider = annotations.getDeprecationsProviderFromAnnotations(session, fromJava = true)
}.build().apply { }.build().apply {
if (isJavaRecordComponent) { if (isJavaRecordComponent) {
this.isJavaRecordComponent = true 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.builtins.StandardNames
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy
import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
@@ -89,7 +88,7 @@ class JavaClassUseSiteMemberScope(
chooseModalityForAccessor(property, delegateGetter) chooseModalityForAccessor(property, delegateGetter)
} }
) )
deprecationsProvider = getDeprecationsProviderFromAccessors(delegateGetter, delegateSetter, session.firCachesFactory) deprecationsProvider = getDeprecationsProviderFromAccessors(session, delegateGetter, delegateSetter)
}.symbol }.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.Name
import org.jetbrains.kotlin.name.StandardClassIds 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 // 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? = private fun FirAnnotation.toAnnotationLookupTagSafe(session: FirSession): ConeClassLikeLookupTag? =
annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.fullyExpandedType(session)?.lookupTag
fun FirAnnotation.toAnnotationClassId(): ClassId? = fun FirAnnotation.toAnnotationClassId(session: FirSession): ClassId? =
toAnnotationLookupTag()?.classId toAnnotationLookupTag(session)?.classId
fun FirAnnotation.toAnnotationClassIdSafe(): ClassId? = private fun FirAnnotation.toAnnotationClassIdSafe(session: FirSession): ClassId? =
toAnnotationLookupTagSafe()?.classId toAnnotationLookupTagSafe(session)?.classId
private fun FirAnnotation.toAnnotationClass(session: FirSession): FirRegularClass? = 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 // TODO: this is temporary solution, we need something better
private val FirExpression.callableNameOfMetaAnnotationArgument: Name? private val FirExpression.callableNameOfMetaAnnotationArgument: Name?
@@ -52,22 +52,22 @@ fun FirAnnotationContainer.nonSourceAnnotations(session: FirSession): List<FirAn
annotations.filter { annotation -> annotations.filter { annotation ->
val firAnnotationClass = annotation.toAnnotationClass(session) val firAnnotationClass = annotation.toAnnotationClass(session)
firAnnotationClass != null && firAnnotationClass.annotations.none { meta -> firAnnotationClass != null && firAnnotationClass.annotations.none { meta ->
meta.toAnnotationClassId() == StandardClassIds.Annotations.Retention && meta.toAnnotationClassId(session) == StandardClassIds.Annotations.Retention &&
meta.findArgumentByName(StandardClassIds.Annotations.ParameterNames.retentionValue) meta.findArgumentByName(StandardClassIds.Annotations.ParameterNames.retentionValue)
?.callableNameOfMetaAnnotationArgument == sourceName ?.callableNameOfMetaAnnotationArgument == sourceName
} }
} }
inline val FirProperty.hasJvmFieldAnnotation: Boolean @Suppress("NOTHING_TO_INLINE")
get() = annotations.any { it.isJvmFieldAnnotation } inline fun FirProperty.hasJvmFieldAnnotation(session: FirSession): Boolean = annotations.any { it.isJvmFieldAnnotation(session) }
val FirAnnotation.isJvmFieldAnnotation: Boolean fun FirAnnotation.isJvmFieldAnnotation(session: FirSession): Boolean =
get() = toAnnotationClassId() == StandardClassIds.Annotations.JvmField toAnnotationClassId(session) == StandardClassIds.Annotations.JvmField
fun FirAnnotation.useSiteTargetsFromMetaAnnotation(session: FirSession): Set<AnnotationUseSiteTarget> { fun FirAnnotation.useSiteTargetsFromMetaAnnotation(session: FirSession): Set<AnnotationUseSiteTarget> {
return toAnnotationClass(session) return toAnnotationClass(session)
?.annotations ?.annotations
?.find { it.toAnnotationClassId() == StandardClassIds.Annotations.Target } ?.find { it.toAnnotationClassId(session) == StandardClassIds.Annotations.Target }
?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.targetAllowedTargets) ?.findArgumentByName(StandardClassIds.Annotations.ParameterNames.targetAllowedTargets)
?.unwrapVarargValue() ?.unwrapVarargValue()
?.toAnnotationUseSiteTargets() ?.toAnnotationUseSiteTargets()
@@ -101,45 +101,47 @@ private val USE_SITE_TARGET_NAME_MAP = mapOf(
private val DEFAULT_USE_SITE_TARGETS: Set<AnnotationUseSiteTarget> = private val DEFAULT_USE_SITE_TARGETS: Set<AnnotationUseSiteTarget> =
USE_SITE_TARGET_NAME_MAP.values.fold(setOf<AnnotationUseSiteTarget>()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE) USE_SITE_TARGET_NAME_MAP.values.fold(setOf<AnnotationUseSiteTarget>()) { a, b -> a + b } - setOf(AnnotationUseSiteTarget.FILE)
fun FirDeclaration.hasAnnotation(classId: ClassId): Boolean { fun FirDeclaration.hasAnnotation(classId: ClassId, session: FirSession): Boolean {
return annotations.hasAnnotation(classId) return annotations.hasAnnotation(classId, session)
} }
fun FirDeclaration.hasAnnotationSafe(classId: ClassId): Boolean { fun FirDeclaration.hasAnnotationSafe(classId: ClassId, session: FirSession): Boolean {
return annotations.hasAnnotationSafe(classId) return annotations.hasAnnotationSafe(classId, session)
} }
fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId): Boolean { fun FirBasedSymbol<*>.hasAnnotation(classId: ClassId, session: FirSession): Boolean {
return resolvedAnnotationsWithClassIds.hasAnnotation(classId) return resolvedAnnotationsWithClassIds.hasAnnotation(classId, session)
} }
fun List<FirAnnotation>.hasAnnotation(classId: ClassId): Boolean { fun List<FirAnnotation>.hasAnnotation(classId: ClassId, session: FirSession): Boolean {
return this.any { it.toAnnotationClassId() == classId } return this.any { it.toAnnotationClassId(session) == classId }
} }
fun List<FirAnnotation>.hasAnnotationSafe(classId: ClassId): Boolean { fun List<FirAnnotation>.hasAnnotationSafe(classId: ClassId, session: FirSession): Boolean {
return this.any { it.toAnnotationClassIdSafe() == classId } return this.any { it.toAnnotationClassIdSafe(session) == classId }
} }
fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(classId: ClassId): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration { fun <D> FirBasedSymbol<out D>.getAnnotationByClassId(
return fir.getAnnotationByClassId(classId) classId: ClassId,
session: FirSession
): FirAnnotation? where D : FirAnnotationContainer, D : FirDeclaration {
return fir.getAnnotationByClassId(classId, session)
} }
fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId): FirAnnotation? { fun FirAnnotationContainer.getAnnotationByClassId(classId: ClassId, session: FirSession): FirAnnotation? {
return annotations.getAnnotationByClassId(classId) return annotations.getAnnotationByClassId(classId, session)
} }
fun List<FirAnnotation>.getAnnotationByClassId(classId: ClassId): FirAnnotation? { fun List<FirAnnotation>.getAnnotationByClassId(classId: ClassId, session: FirSession): FirAnnotation? {
return find { return getAnnotationsByClassId(classId, session).firstOrNull()
it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.lookupTag?.classId == classId
}
} }
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 { 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 return typeRef.coneType.typeArguments.getOrNull(0)?.type
} }
fun FirAnnotationContainer.getJvmNameFromAnnotation(target: AnnotationUseSiteTarget? = null): String? { fun FirAnnotationContainer.getJvmNameFromAnnotation(session: FirSession, target: AnnotationUseSiteTarget? = null): String? {
val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName) val annotationCalls = getAnnotationsByClassId(StandardClassIds.Annotations.JvmName, session)
return annotationCalls.firstNotNullOfOrNull { call -> return annotationCalls.firstNotNullOfOrNull { call ->
call.getStringArgument(StandardClassIds.Annotations.ParameterNames.jvmNameName) call.getStringArgument(StandardClassIds.Annotations.ParameterNames.jvmNameName)
?.takeIf { target == null || call.useSiteTarget == target } ?.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.FirElement
import org.jetbrains.kotlin.fir.FirSession 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.caches.firCachesFactory
import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.languageVersionSettings
import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -90,33 +91,36 @@ fun FirBasedSymbol<*>.getDeprecation(apiVersion: ApiVersion, callSite: FirElemen
} }
} }
fun FirAnnotationContainer.getDeprecationsProvider(firCachesFactory: FirCachesFactory): DeprecationsProvider { fun FirAnnotationContainer.getDeprecationsProvider(session: FirSession): DeprecationsProvider {
return extractDeprecationInfoPerUseSite().toDeprecationsProvider(firCachesFactory) return extractDeprecationInfoPerUseSite(session).toDeprecationsProvider(session.firCachesFactory)
} }
fun FirAnnotationContainer.extractDeprecationInfoPerUseSite(): DeprecationAnnotationInfoPerUseSiteStorage { fun FirAnnotationContainer.extractDeprecationInfoPerUseSite(session: FirSession): DeprecationAnnotationInfoPerUseSiteStorage {
val fromJava = this is FirDeclaration && this.isJavaOrEnhancement val fromJava = this is FirDeclaration && this.isJavaOrEnhancement
return buildDeprecationAnnotationInfoPerUseSiteStorage { return buildDeprecationAnnotationInfoPerUseSiteStorage {
add(annotations.extractDeprecationAnnotationInfoPerUseSite(fromJava)) add(annotations.extractDeprecationAnnotationInfoPerUseSite(session, fromJava))
if (this@extractDeprecationInfoPerUseSite is FirProperty) { if (this@extractDeprecationInfoPerUseSite is FirProperty) {
add(getDeprecationsAnnotationInfoByUseSiteFromAccessors(getter, setter)) add(getDeprecationsAnnotationInfoByUseSiteFromAccessors(session, getter, setter))
} }
} }
} }
fun getDeprecationsProviderFromAccessors( fun getDeprecationsProviderFromAccessors(
session: FirSession,
getter: FirFunction?, getter: FirFunction?,
setter: FirFunction?, setter: FirFunction?
firCachesFactory: FirCachesFactory
): DeprecationsProvider { ): DeprecationsProvider {
return getDeprecationsAnnotationInfoByUseSiteFromAccessors(getter, setter).toDeprecationsProvider(firCachesFactory) return getDeprecationsAnnotationInfoByUseSiteFromAccessors(session, getter, setter).toDeprecationsProvider(session.firCachesFactory)
} }
fun getDeprecationsAnnotationInfoByUseSiteFromAccessors( fun getDeprecationsAnnotationInfoByUseSiteFromAccessors(
session: FirSession,
getter: FirFunction?, getter: FirFunction?,
setter: FirFunction? setter: FirFunction?
): DeprecationAnnotationInfoPerUseSiteStorage { ): DeprecationAnnotationInfoPerUseSiteStorage {
return buildDeprecationAnnotationInfoPerUseSiteStorage { return buildDeprecationAnnotationInfoPerUseSiteStorage {
val setterDeprecations = setter?.extractDeprecationInfoPerUseSite() val setterDeprecations = setter?.extractDeprecationInfoPerUseSite(session)
setterDeprecations?.storage?.forEach { (useSite, infos) -> setterDeprecations?.storage?.forEach { (useSite, infos) ->
if (useSite == null) { if (useSite == null) {
add(AnnotationUseSiteTarget.PROPERTY_SETTER, infos) add(AnnotationUseSiteTarget.PROPERTY_SETTER, infos)
@@ -124,7 +128,7 @@ fun getDeprecationsAnnotationInfoByUseSiteFromAccessors(
add(useSite, infos) add(useSite, infos)
} }
} }
val getterDeprecations = getter?.extractDeprecationInfoPerUseSite() val getterDeprecations = getter?.extractDeprecationInfoPerUseSite(session)
getterDeprecations?.storage?.forEach { (useSite, infos) -> getterDeprecations?.storage?.forEach { (useSite, infos) ->
if (useSite == null) { if (useSite == null) {
add(AnnotationUseSiteTarget.PROPERTY_GETTER, infos) add(AnnotationUseSiteTarget.PROPERTY_GETTER, infos)
@@ -136,11 +140,11 @@ fun getDeprecationsAnnotationInfoByUseSiteFromAccessors(
} }
fun List<FirAnnotation>.getDeprecationsProviderFromAnnotations( fun List<FirAnnotation>.getDeprecationsProviderFromAnnotations(
fromJava: Boolean, session: FirSession,
firCachesFactory: FirCachesFactory fromJava: Boolean
): DeprecationsProvider { ): DeprecationsProvider {
val deprecationAnnotationByUseSite = extractDeprecationAnnotationInfoPerUseSite(fromJava) val deprecationAnnotationByUseSite = extractDeprecationAnnotationInfoPerUseSite(session, fromJava)
return deprecationAnnotationByUseSite.toDeprecationsProvider(firCachesFactory) return deprecationAnnotationByUseSite.toDeprecationsProvider(session.firCachesFactory)
} }
fun FirBasedSymbol<*>.getDeprecationForCallSite( fun FirBasedSymbol<*>.getDeprecationForCallSite(
@@ -175,7 +179,7 @@ private fun FirAnnotation.getDeprecationLevel(): DeprecationLevelValue? {
} }
private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite( private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
fromJava: Boolean session: FirSession, fromJava: Boolean
): DeprecationAnnotationInfoPerUseSiteStorage { ): DeprecationAnnotationInfoPerUseSiteStorage {
@Suppress("RemoveExplicitTypeArguments") @Suppress("RemoveExplicitTypeArguments")
val annotations = buildList<Pair<FirAnnotation, Boolean>> { val annotations = buildList<Pair<FirAnnotation, Boolean>> {
@@ -199,7 +203,9 @@ private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
} else { } else {
val deprecationLevel = deprecated.getDeprecationLevel() ?: DeprecationLevelValue.WARNING val deprecationLevel = deprecated.getDeprecationLevel() ?: DeprecationLevelValue.WARNING
val propagatesToOverride = !fromJavaAnnotation && !fromJava 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 message = deprecated.getStringArgument(ParameterNames.deprecatedMessage)
val deprecatedInfo = 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) return lookupTag.toSymbol(session)
} }
fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParameter): ConeKotlinType { fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParameter, session: FirSession): ConeKotlinType {
val name = parameter.name val name = parameter.name
if (name == null || name == SpecialNames.NO_NAME_PROVIDED || name == SpecialNames.UNDERSCORE_FOR_UNUSED_VAR) return this if (name == null || name == SpecialNames.NO_NAME_PROVIDED || name == SpecialNames.UNDERSCORE_FOR_UNUSED_VAR) return this
// Existing @ParameterName annotation takes precedence // 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 fakeSource = parameter.source?.fakeElement(KtFakeSourceElementKind.ParameterNameAnnotationCall)
val parameterNameAnnotationCall = buildAnnotation { 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 package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty
import org.jetbrains.kotlin.fir.declarations.utils.isStatic import org.jetbrains.kotlin.fir.declarations.utils.isStatic
@@ -138,7 +137,7 @@ class FirSyntheticPropertiesScope private constructor(
) )
delegateGetter = getter delegateGetter = getter
delegateSetter = matchingSetter delegateSetter = matchingSetter
deprecationsProvider = getDeprecationsProviderFromAccessors(getter, matchingSetter, session.firCachesFactory) deprecationsProvider = getDeprecationsProviderFromAccessors(session, getter, matchingSetter)
} }
val syntheticSymbol = property.symbol val syntheticSymbol = property.symbol
(baseScope as? FirUnstableSmartcastTypeScope)?.apply { (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.FirSession
import org.jetbrains.kotlin.fir.FirSessionComponent 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.resolve.getSymbolByLookupTag
import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.getDeclaredConstructors 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.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.symbols.impl.*
import org.jetbrains.kotlin.fir.types.ConeLookupTagBasedType 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.FirTypeRef
import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.name.ClassId 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? { 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 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.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.builder.* import org.jetbrains.kotlin.fir.declarations.builder.*
import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
@@ -566,7 +565,7 @@ object FirFakeOverrideGenerator {
delegateGetter = getter delegateGetter = getter
delegateSetter = setter delegateSetter = setter
status = baseProperty.status status = baseProperty.status
deprecationsProvider = getDeprecationsProviderFromAccessors(getter, setter, session.firCachesFactory) deprecationsProvider = getDeprecationsProviderFromAccessors(session, getter, setter)
}.apply { }.apply {
containingClassForStaticMemberAttr = derivedClassLookupTag.takeIf { shouldOverrideSetContainingClass(baseProperty) } containingClassForStaticMemberAttr = derivedClassLookupTag.takeIf { shouldOverrideSetContainingClass(baseProperty) }
}.symbol }.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 = val annotationClass =
annotation.annotationTypeRef.coneType.fullyExpandedType(context.session).toSymbol(context.session) as? FirClassSymbol annotation.annotationTypeRef.coneType.fullyExpandedType(context.session).toSymbol(context.session) as? FirClassSymbol
?: continue ?: continue
if (annotationClass.hasAnnotation(dslMarkerClassId)) { if (annotationClass.hasAnnotation(dslMarkerClassId, context.session)) {
add(annotationClass.classId) add(annotationClass.classId)
} }
} }
@@ -608,7 +608,7 @@ internal object PostponedVariablesInitializerResolutionStage : ResolutionStage()
// TODO: convert type argument mapping to map [FirTypeParameterSymbol, FirTypedProjection?] // TODO: convert type argument mapping to map [FirTypeParameterSymbol, FirTypedProjection?]
if (candidate.typeArgumentMapping is TypeArgumentMapping.Mapped) return if (candidate.typeArgumentMapping is TypeArgumentMapping.Mapped) return
for (parameter in argumentMapping.values) { for (parameter in argumentMapping.values) {
if (!parameter.hasBuilderInferenceAnnotation()) continue if (!parameter.hasBuilderInferenceAnnotation(context.session)) continue
val type = parameter.returnTypeRef.coneType val type = parameter.returnTypeRef.coneType
val receiverType = type.receiverType(callInfo.session) ?: continue val receiverType = type.receiverType(callInfo.session) ?: continue
val dontUseBuilderInferenceIfPossible = val dontUseBuilderInferenceIfPossible =
@@ -665,7 +665,8 @@ internal object ProcessDynamicExtensionAnnotation : ResolutionStage() {
val argumentIsDynamic = extensionReceiver.type is ConeDynamicType val argumentIsDynamic = extensionReceiver.type is ConeDynamicType
val parameterIsDynamic = (candidate.symbol as? FirCallableSymbol)?.resolvedReceiverTypeRef?.type is ConeDynamicType val parameterIsDynamic = (candidate.symbol as? FirCallableSymbol)?.resolvedReceiverTypeRef?.type is ConeDynamicType
if (parameterIsDynamic != argumentIsDynamic || 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) 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> processor: TowerScopeLevelProcessor<T>
) { ) {
val candidateReceiverTypeRef = candidate.fir.receiverParameter?.typeRef val candidateReceiverTypeRef = candidate.fir.receiverParameter?.typeRef
if (withHideMembersOnly && candidate.getAnnotationByClassId(HidesMembers) == null) { if (withHideMembersOnly && candidate.getAnnotationByClassId(HidesMembers, session) == null) {
return return
} }
val receiverExpected = withHideMembersOnly || areThereExtensionReceiverOptions() 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 package org.jetbrains.kotlin.fir.resolve.inference
import org.jetbrains.kotlin.fir.FirElement 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.FirAnonymousFunction
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.hasAnnotation import org.jetbrains.kotlin.fir.declarations.hasAnnotation
@@ -35,6 +36,7 @@ class FirBuilderInferenceSession(
resolutionContext: ResolutionContext, resolutionContext: ResolutionContext,
private val stubsForPostponedVariables: Map<ConeTypeVariable, ConeStubType>, private val stubsForPostponedVariables: Map<ConeTypeVariable, ConeStubType>,
) : FirInferenceSessionForChainedResolve(resolutionContext) { ) : FirInferenceSessionForChainedResolve(resolutionContext) {
private val session = resolutionContext.session
private val commonCalls: MutableList<Pair<FirStatement, Candidate>> = mutableListOf() private val commonCalls: MutableList<Pair<FirStatement, Candidate>> = mutableListOf()
private var lambdaImplicitReceivers: MutableList<ImplicitExtensionReceiverValue> = mutableListOf() private var lambdaImplicitReceivers: MutableList<ImplicitExtensionReceiverValue> = mutableListOf()
@@ -72,7 +74,7 @@ class FirBuilderInferenceSession(
return when { return when {
extensionReceiver == null && dispatchReceiver == null -> false extensionReceiver == null && dispatchReceiver == null -> false
dispatchReceiver?.type?.containsStubType() == true -> true dispatchReceiver?.type?.containsStubType() == true -> true
extensionReceiver?.type?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation() extensionReceiver?.type?.containsStubType() == true -> symbol.fir.hasBuilderInferenceAnnotation(session)
else -> false else -> false
} }
} }
@@ -272,4 +274,5 @@ class FirStubTypeTransformer(
private val BUILDER_INFERENCE_ANNOTATION_CLASS_ID: ClassId = ClassId.topLevel(BUILDER_INFERENCE_ANNOTATION_FQ_NAME) 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 = val parameters =
typeRef.contextReceiverTypeRefs.map { it.coneType } + typeRef.contextReceiverTypeRefs.map { it.coneType } +
listOfNotNull(typeRef.receiverTypeRef?.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) listOf(typeRef.returnTypeRef.coneType)
val classId = if (typeRef.isSuspend) { val classId = if (typeRef.isSuspend) {
StandardClassIds.SuspendFunctionN(typeRef.parametersCount) 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 package org.jetbrains.kotlin.fir.resolve.transformers
import org.jetbrains.kotlin.fir.FirSession 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.*
import org.jetbrains.kotlin.fir.declarations.utils.isInline import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -488,7 +487,7 @@ abstract class AbstractFirStatusResolveTransformer(
private fun calculateDeprecations(simpleFunction: FirCallableDeclaration) { private fun calculateDeprecations(simpleFunction: FirCallableDeclaration) {
if (simpleFunction.deprecationsProvider is UnresolvedDeprecationProvider) { 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.FirElement
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.PrivateForInline import org.jetbrains.kotlin.fir.PrivateForInline
import org.jetbrains.kotlin.fir.caches.firCachesFactory
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirAnnotation import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
@@ -194,7 +193,9 @@ internal abstract class AbstractFirSpecificAnnotationResolveTransformer(
private fun calculateDeprecations(classLikeDeclaration: FirClassLikeDeclaration) { private fun calculateDeprecations(classLikeDeclaration: FirClassLikeDeclaration) {
if (classLikeDeclaration.deprecationsProvider == UnresolvedDeprecationProvider) { 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 // TARGET_BACKEND: JVM
// due to KT-55615
// IGNORE_BACKEND_K2: JVM_IR
// WITH_STDLIB // WITH_STDLIB
// FULL_JDK // 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 // !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER
import kotlin.jvm.Volatile as JvmVolatile import kotlin.jvm.Volatile as JvmVolatile
import kotlin.concurrent.Volatile 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> { ): List<FirResolvedTypeRef> {
if (resolvedSupertypes.any { it.type.classId == supertypeClassId }) return emptyList() 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 getClassArgument = (annotation as? FirAnnotationCall)?.argument as? FirGetClassCall ?: return emptyList()
val typeToResolve = buildUserTypeFromQualifierParts(isMarkedNullable = false) { 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, override val isConstructorParameterWithDefault: Boolean,
declaresDefaultValue: Boolean declaresDefaultValue: Boolean
) : ISerializableProperty { ) : ISerializableProperty {
override val name: String = propertySymbol.serialNameValue ?: propertySymbol.name.asString() override val name: String = propertySymbol.getSerialNameValue(session) ?: propertySymbol.name.asString()
override val originalDescriptorName: Name override val originalDescriptorName: Name
get() = propertySymbol.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() ?: 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() if (resolvedSupertypes.any { it.type.classId == kSerializerClassId || it.type.classId == generatedSerializerClassId }) return emptyList()
return if (session.predicateBasedProvider.matches(serializerFor, classLikeDeclaration)) { return if (session.predicateBasedProvider.matches(serializerFor, classLikeDeclaration)) {
val getClassArgument = classLikeDeclaration.serializerFor ?: return emptyList() val getClassArgument = classLikeDeclaration.getSerializerFor(session) ?: return emptyList()
val serializerConeType = resolveConeTypeFromArgument(getClassArgument) val serializerConeType = resolveConeTypeFromArgument(getClassArgument)
listOf( 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 ---------------------- // ---------------------- annotations utils ----------------------
context(FirSession)
val FirBasedSymbol<*>.isSerialInfoAnnotation: Boolean val FirBasedSymbol<*>.isSerialInfoAnnotation: Boolean
get() = hasAnnotation(serialInfoClassId) get() = hasAnnotation(serialInfoClassId, this@FirSession)
|| hasAnnotation(inheritableSerialInfoClassId) || hasAnnotation(inheritableSerialInfoClassId, this@FirSession)
|| hasAnnotation(metaSerializableAnnotationClassId) || hasAnnotation(metaSerializableAnnotationClassId, this@FirSession)
val FirBasedSymbol<*>.isInheritableSerialInfoAnnotation: Boolean fun FirBasedSymbol<*>.isInheritableSerialInfoAnnotation(session: FirSession): Boolean =
get() = hasAnnotation(inheritableSerialInfoClassId) hasAnnotation(inheritableSerialInfoClassId, session)
val FirBasedSymbol<*>.serialNameAnnotation: FirAnnotation? fun FirBasedSymbol<*>.getSerialNameAnnotation(session: FirSession): FirAnnotation? =
get() = resolvedAnnotationsWithArguments.getAnnotationByClassId(serialNameAnnotationClassId) resolvedAnnotationsWithArguments.getAnnotationByClassId(serialNameAnnotationClassId, session)
val FirBasedSymbol<*>.serialNameValue: String? fun FirBasedSymbol<*>.getSerialNameValue(session: FirSession): String? =
get() = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE) getSerialNameAnnotation(session)?.getStringArgument(AnnotationParameterNames.VALUE)
val FirBasedSymbol<*>.serialRequired: Boolean fun FirBasedSymbol<*>.getSerialRequired(session: FirSession): Boolean =
get() = hasAnnotation(SerializationAnnotations.requiredAnnotationClassId) hasAnnotation(SerializationAnnotations.requiredAnnotationClassId, session)
val FirBasedSymbol<*>.hasSerialTransient: Boolean fun FirBasedSymbol<*>.hasSerialTransient(session: FirSession): Boolean = getSerialTransientAnnotation(session) != null
get() = serialTransientAnnotation != null
val FirBasedSymbol<*>.serialTransientAnnotation: FirAnnotation? fun FirBasedSymbol<*>.getSerialTransientAnnotation(session: FirSession): FirAnnotation? =
get() = getAnnotationByClassId(SerializationAnnotations.serialTransientClassId) getAnnotationByClassId(SerializationAnnotations.serialTransientClassId, session)
context(FirSession)
@Suppress("IncorrectFormatting") // KTIJ-22227
val FirClassSymbol<*>.hasSerializableAnnotation: Boolean 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 val annotations = if (needArguments) resolvedAnnotationsWithClassIds else resolvedAnnotationsWithArguments
return annotations.serializableAnnotation() return annotations.serializableAnnotation(session)
} }
fun List<FirAnnotation>.serializableAnnotation(): FirAnnotation? { fun List<FirAnnotation>.serializableAnnotation(session: FirSession): FirAnnotation? {
return getAnnotationByClassId(SerializationAnnotations.serializableAnnotationClassId) return getAnnotationByClassId(SerializationAnnotations.serializableAnnotationClassId, session)
} }
val FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs: Boolean fun FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs(session: FirSession): Boolean =
get() = serializableAnnotation(needArguments = false)?.let { serializableAnnotation(needArguments = false, session)?.let {
if (it is FirAnnotationCall) { if (it is FirAnnotationCall) {
it.arguments.isEmpty() it.arguments.isEmpty()
} else { } else {
@@ -83,27 +85,26 @@ val FirClassSymbol<*>.hasSerializableAnnotationWithoutArgs: Boolean
} }
} ?: false } ?: false
internal val FirBasedSymbol<*>.serializableWith: ConeKotlinType? internal fun FirBasedSymbol<*>.getSerializableWith(session: FirSession): ConeKotlinType? =
get() = serializableAnnotation(needArguments = true)?.getKClassArgument(AnnotationParameterNames.WITH) serializableAnnotation(needArguments = true, session)?.getKClassArgument(AnnotationParameterNames.WITH)
internal val List<FirAnnotation>.serializableWith: ConeKotlinType? internal fun List<FirAnnotation>.getSerializableWith(session: FirSession): ConeKotlinType? =
get() = serializableAnnotation()?.getKClassArgument(AnnotationParameterNames.WITH) serializableAnnotation(session)?.getKClassArgument(AnnotationParameterNames.WITH)
fun FirAnnotation.getGetKClassArgument(name: Name): FirGetClassCall? { fun FirAnnotation.getGetKClassArgument(name: Name): FirGetClassCall? {
return findArgumentByName(name) as? FirGetClassCall return findArgumentByName(name) as? FirGetClassCall
} }
internal val FirClassSymbol<*>.serializerAnnotation: FirAnnotation? internal fun FirClassSymbol<*>.getSerializerAnnotation(session: FirSession): FirAnnotation? =
get() = getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId) getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session)
// ---------------------- class utils ---------------------- // ---------------------- class utils ----------------------
internal val FirClassSymbol<*>.serializerForClass: ConeKotlinType? internal fun FirClassSymbol<*>.getSerializerForClass(session: FirSession): ConeKotlinType? = resolvedAnnotationsWithArguments
get() = resolvedAnnotationsWithArguments .getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session)
.getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId) ?.getKClassArgument(AnnotationParameterNames.FOR_CLASS)
?.getKClassArgument(AnnotationParameterNames.FOR_CLASS)
internal val FirClassLikeDeclaration.serializerFor: FirGetClassCall? internal fun FirClassLikeDeclaration.getSerializerFor(session: FirSession): FirGetClassCall? =
get() = getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId) getAnnotationByClassId(SerializationAnnotations.serializerAnnotationClassId, session)
?.getGetKClassArgument(AnnotationParameterNames.FOR_CLASS) ?.getGetKClassArgument(AnnotationParameterNames.FOR_CLASS)
context(FirSession) context(FirSession)
@@ -147,7 +148,8 @@ internal val FirClassSymbol<*>.isInternalSerializable: Boolean
context(FirSession) context(FirSession)
val FirClassSymbol<*>.hasSerializableOrMetaAnnotationWithoutArgs: Boolean val FirClassSymbol<*>.hasSerializableOrMetaAnnotationWithoutArgs: Boolean
get() = hasSerializableAnnotationWithoutArgs || (!hasSerializableAnnotation && hasMetaSerializableAnnotation) get() = hasSerializableAnnotationWithoutArgs(this@FirSession) ||
(!hasSerializableAnnotation && hasMetaSerializableAnnotation)
context(FirSession) context(FirSession)
@Suppress("IncorrectFormatting") // KTIJ-22227 @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.config.KotlinCompilerVersion
import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.diagnostics.* 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.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirClassChecker
import org.jetbrains.kotlin.fir.analysis.checkers.isSingleFieldValueClass 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.moduleData
import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.defaultType
import org.jetbrains.kotlin.fir.resolve.fullyExpandedType 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.symbols.impl.*
import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.name.* 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.kotlin.types.AbstractTypeChecker
import org.jetbrains.kotlinx.serialization.compiler.diagnostic.RuntimeVersions import org.jetbrains.kotlinx.serialization.compiler.diagnostic.RuntimeVersions
import org.jetbrains.kotlinx.serialization.compiler.fir.* 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.dependencySerializationInfoProvider
import org.jetbrains.kotlinx.serialization.compiler.fir.services.findTypeSerializerOrContextUnchecked import org.jetbrains.kotlinx.serialization.compiler.fir.services.findTypeSerializerOrContextUnchecked
import org.jetbrains.kotlinx.serialization.compiler.fir.services.serializablePropertiesProvider import org.jetbrains.kotlinx.serialization.compiler.fir.services.serializablePropertiesProvider
@@ -73,11 +71,11 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
context(CheckerContext) context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
private fun checkExternalSerializer(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { 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 serializableClassSymbol = serializableKType.toRegularClassSymbol(session) ?: return
val properties = session.serializablePropertiesProvider.getSerializablePropertiesForClass(serializableClassSymbol) val properties = session.serializablePropertiesProvider.getSerializablePropertiesForClass(serializableClassSymbol)
if (!properties.isExternallySerializable) { 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) { val error = if (serializableClassSymbol.moduleData == session.moduleData) {
FirSerializationErrors.EXTERNAL_CLASS_NOT_SERIALIZABLE FirSerializationErrors.EXTERNAL_CLASS_NOT_SERIALIZABLE
} else { } else {
@@ -93,7 +91,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
private fun checkInheritedAnnotations(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { private fun checkInheritedAnnotations(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) {
fun annotationsFilter(annotations: List<FirAnnotation>): List<Pair<ClassId, FirAnnotation>> { fun annotationsFilter(annotations: List<FirAnnotation>): List<Pair<ClassId, FirAnnotation>> {
return annotations 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 } } .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 if (classSymbol.resolvedSuperTypes.any { it.classId == JAVA_SERIALIZABLE_ID }) return // do not check
for (property in properties) { for (property in properties) {
if (property.transient) continue 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) { if (incorrectTransient != null) {
reporter.reportOn( reporter.reportOn(
source = incorrectTransient.source ?: property.propertySymbol.source, source = incorrectTransient.source ?: property.propertySymbol.source,
@@ -277,8 +275,8 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
private fun checkCompanionSerializerDependency(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) = with(session) { private fun checkCompanionSerializerDependency(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) = with(session) {
if (classSymbol !is FirRegularClassSymbol) return if (classSymbol !is FirRegularClassSymbol) return
val companionObjectSymbol = classSymbol.companionObjectSymbol ?: return val companionObjectSymbol = classSymbol.companionObjectSymbol ?: return
val serializerForInCompanion = companionObjectSymbol.serializerForClass?.toRegularClassSymbol(session) ?: return val serializerForInCompanion = companionObjectSymbol.getSerializerForClass(session)?.toRegularClassSymbol(session) ?: return
val serializableWith: ConeKotlinType? = classSymbol.serializableWith val serializableWith: ConeKotlinType? = classSymbol.getSerializableWith(session)
if (classSymbol.hasSerializableOrMetaAnnotationWithoutArgs) { if (classSymbol.hasSerializableOrMetaAnnotationWithoutArgs) {
if (serializerForInCompanion.classId == classSymbol.classId) { if (serializerForInCompanion.classId == classSymbol.classId) {
// @Serializable class Foo / @Serializer(Foo::class) companion object — prohibited due to problems with recursive resolve // @Serializable class Foo / @Serializer(Foo::class) companion object — prohibited due to problems with recursive resolve
@@ -289,7 +287,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
) )
} else { } else {
// @Serializable class Foo / @Serializer(Bar::class) companion object — prohibited as vague and confusing // @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( reporter.reportOn(
source, source,
FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS, FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS,
@@ -303,7 +301,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
} else { } else {
// @Serializable(anySer) class Foo / @Serializer(anyOtherClass) companion object — prohibited as vague and confusing // @Serializable(anySer) class Foo / @Serializer(anyOtherClass) companion object — prohibited as vague and confusing
reporter.reportOn( reporter.reportOn(
companionObjectSymbol.serializerAnnotation?.source, companionObjectSymbol.getSerializerAnnotation(session)?.source,
FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS, FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_OTHER_SERIALIZABLE_CLASS,
classSymbol.defaultType(), classSymbol.defaultType(),
serializerForInCompanion.defaultType() serializerForInCompanion.defaultType()
@@ -312,7 +310,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
} else { } else {
// (regular) class Foo / @Serializer(something) companion object - not recommended // (regular) class Foo / @Serializer(something) companion object - not recommended
reporter.reportOn( reporter.reportOn(
companionObjectSymbol.serializerAnnotation?.source, companionObjectSymbol.getSerializerAnnotation(session)?.source,
FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_NON_SERIALIZABLE_CLASS, FirSerializationErrors.COMPANION_OBJECT_SERIALIZER_INSIDE_NON_SERIALIZABLE_CLASS,
classSymbol.defaultType(), classSymbol.defaultType(),
serializerForInCompanion.defaultType() serializerForInCompanion.defaultType()
@@ -324,7 +322,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
context(CheckerContext) context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
private fun checkClassWithCustomSerializer(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { 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) checkCustomSerializerMatch(classSymbol, source = null, classSymbol.defaultType(), serializerType, reporter)
checkCustomSerializerIsNotLocal(source = null, classSymbol, serializerType, reporter) checkCustomSerializerIsNotLocal(source = null, classSymbol, serializerType, reporter)
} }
@@ -343,12 +341,12 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
if (!classSymbol.isEnumClass) return if (!classSymbol.isEnumClass) return
val entryBySerialName = mutableMapOf<String, FirEnumEntrySymbol>() val entryBySerialName = mutableMapOf<String, FirEnumEntrySymbol>()
for (enumEntrySymbol in classSymbol.collectEnumEntries()) { for (enumEntrySymbol in classSymbol.collectEnumEntries()) {
val serialNameAnnotation = enumEntrySymbol.serialNameAnnotation val serialNameAnnotation = enumEntrySymbol.getSerialNameAnnotation(session)
val serialName = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE) ?: enumEntrySymbol.name.asString() val serialName = serialNameAnnotation?.getStringArgument(AnnotationParameterNames.VALUE) ?: enumEntrySymbol.name.asString()
val firstEntry = entryBySerialName[serialName] val firstEntry = entryBySerialName[serialName]
if (firstEntry != null) { if (firstEntry != null) {
reporter.reportOn( reporter.reportOn(
source = serialNameAnnotation?.source ?: firstEntry.serialNameAnnotation?.source ?: enumEntrySymbol.source, source = serialNameAnnotation?.source ?: firstEntry.getSerialNameAnnotation(session)?.source ?: enumEntrySymbol.source,
FirSerializationErrors.DUPLICATE_SERIAL_NAME_ENUM, FirSerializationErrors.DUPLICATE_SERIAL_NAME_ENUM,
classSymbol, classSymbol,
serialName, serialName,
@@ -394,7 +392,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
private fun checkTransients(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) { private fun checkTransients(classSymbol: FirClassSymbol<*>, reporter: DiagnosticReporter) {
for (propertySymbol in classSymbol.declarationSymbols.filterIsInstance<FirPropertySymbol>()) { for (propertySymbol in classSymbol.declarationSymbols.filterIsInstance<FirPropertySymbol>()) {
val isInitialized = propertySymbol.isLateInit || declarationHasInitializer(propertySymbol) val isInitialized = propertySymbol.isLateInit || declarationHasInitializer(propertySymbol)
val transientAnnotation = propertySymbol.serialTransientAnnotation ?: continue val transientAnnotation = propertySymbol.getSerialTransientAnnotation(session) ?: continue
val hasBackingField = propertySymbol.hasBackingField val hasBackingField = propertySymbol.hasBackingField
if (!hasBackingField) { if (!hasBackingField) {
reporter.reportOn(transientAnnotation.source ?: propertySymbol.source, FirSerializationErrors.TRANSIENT_IS_REDUNDANT) reporter.reportOn(transientAnnotation.source ?: propertySymbol.source, FirSerializationErrors.TRANSIENT_IS_REDUNDANT)
@@ -441,7 +439,7 @@ object FirSerializationPluginClassChecker : FirClassChecker() {
reporter reporter
) )
checkCustomSerializerIsNotLocal( checkCustomSerializerIsNotLocal(
source = propertySymbol.serializableAnnotation(needArguments = false)?.source, source = propertySymbol.serializableAnnotation(needArguments = false, session)?.source,
classSymbol, classSymbol,
customSerializerType, customSerializerType,
reporter 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.Name
import org.jetbrains.kotlin.name.StandardClassIds import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlinx.serialization.compiler.fir.* 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.fir.services.dependencySerializationInfoProvider
import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames
import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations import org.jetbrains.kotlinx.serialization.compiler.resolve.SerializationAnnotations
@@ -46,7 +46,7 @@ internal val FirClassSymbol<*>?.classSerializer: FirClassSymbol<*>?
get() { get() {
if (this == null) return null if (this == null) return null
// serializer annotation on class? // serializer annotation on class?
serializableWith?.let { return it.toRegularClassSymbol(session) } getSerializableWith(session)?.let { return it.toRegularClassSymbol(session) }
// companion object serializer? // companion object serializer?
if (this is FirRegularClassSymbol && with(session) { isInternallySerializableObject }) return companionObjectSymbol if (this is FirRegularClassSymbol && with(session) { isInternallySerializableObject }) return companionObjectSymbol
// can infer @Poly? // can infer @Poly?
@@ -93,7 +93,7 @@ internal val FirAnnotation.annotationClassSymbol: FirRegularClassSymbol?
context(CheckerContext) context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
internal val FirAnnotation.isMetaSerializableAnnotation: Boolean internal val FirAnnotation.isMetaSerializableAnnotation: Boolean
get() = annotationClassSymbol?.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationClassId) ?: false get() = annotationClassSymbol?.hasAnnotation(SerializationAnnotations.metaSerializableAnnotationClassId, session) ?: false
context(CheckerContext) context(CheckerContext)
@@ -107,7 +107,7 @@ context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceElement? internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceElement?
get() { get() {
serializableAnnotation(needArguments = false)?.source?.let { return it } serializableAnnotation(needArguments = false, session)?.source?.let { return it }
metaSerializableAnnotation(needArguments = false)?.source?.let { return it } metaSerializableAnnotation(needArguments = false)?.source?.let { return it }
return null return null
} }
@@ -115,7 +115,9 @@ internal val FirClassSymbol<*>.serializableOrMetaAnnotationSource: KtSourceEleme
context(CheckerContext) context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
internal val FirBasedSymbol<*>.hasAnySerialAnnotation: Boolean 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 ---------------------- // ---------------------- class utils ----------------------
@@ -155,13 +157,13 @@ internal val FirClassSymbol<*>.serializableAnnotationIsUseless: Boolean
context(CheckerContext) context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
internal val ConeKotlinType.serializableWith: ConeKotlinType? internal val ConeKotlinType.serializableWith: ConeKotlinType?
get() = customAnnotations.serializableWith ?: toRegularClassSymbol(session)?.serializableWith get() = customAnnotations.getSerializableWith(session) ?: toRegularClassSymbol(session)?.getSerializableWith(session)
context(CheckerContext) context(CheckerContext)
@Suppress("IncorrectFormatting") // KTIJ-22227 @Suppress("IncorrectFormatting") // KTIJ-22227
internal val ConeKotlinType.overriddenSerializer: ConeKotlinType? internal val ConeKotlinType.overriddenSerializer: ConeKotlinType?
get() = toRegularClassSymbol(session)?.serializableWith get() = toRegularClassSymbol(session)?.getSerializableWith(session)
// ---------------------- others ---------------------- // ---------------------- 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> { 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()) { val arguments = when (val argument = annotation.argumentMapping.mapping.values.firstOrNull()) {
is FirArrayOfCall -> argument.arguments is FirArrayOfCall -> argument.arguments
is FirVarargArgumentsExpression -> argument.arguments is FirVarargArgumentsExpression -> argument.arguments
@@ -79,7 +81,7 @@ context(CheckerContext)
fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<*>? { fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<*>? {
if (type.isTypeParameter) return null if (type.isTypeParameter) return null
val annotations = type.fullyExpandedType(session).customAnnotations 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 classSymbol = type.toRegularClassSymbol(session) ?: return null
val currentFile = currentFile val currentFile = currentFile
val provider = session.contextualSerializersProvider val provider = session.contextualSerializersProvider
@@ -98,12 +100,12 @@ fun findTypeSerializerOrContextUnchecked(type: ConeKotlinType): FirClassSymbol<*
* if [annotations] contains @Contextual or @Polymorphic annotation * if [annotations] contains @Contextual or @Polymorphic annotation
*/ */
fun analyzeSpecialSerializers(session: FirSession, annotations: List<FirAnnotation>): FirClassSymbol<*>? = when { fun analyzeSpecialSerializers(session: FirSession, annotations: List<FirAnnotation>): FirClassSymbol<*>? = when {
annotations.hasAnnotation(SerializationAnnotations.contextualClassId) || annotations.hasAnnotation(SerializationAnnotations.contextualClassId, session) ||
annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyClassId) -> { annotations.hasAnnotation(SerializationAnnotations.contextualOnPropertyClassId, session) -> {
session.dependencySerializationInfoProvider.getClassFromSerializationPackage(SpecialBuiltins.Names.contextSerializer) session.dependencySerializationInfoProvider.getClassFromSerializationPackage(SpecialBuiltins.Names.contextSerializer)
} }
// can be annotation on type usage, e.g. List<@Polymorphic Any> // 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) 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 { fun isPropertySerializable(propertySymbol: FirPropertySymbol): Boolean {
return when { return when {
isInternalSerializable -> !propertySymbol.hasSerialTransient isInternalSerializable -> !propertySymbol.hasSerialTransient(session)
propertySymbol.visibility == Visibilities.Private -> false 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() { object FirParcelizePropertyChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { 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 val fromPrimaryConstructor = declaration.fromPrimaryConstructor ?: false
if ( if (
!fromPrimaryConstructor && !fromPrimaryConstructor &&
(declaration.hasBackingField || declaration.delegate != null) && (declaration.hasBackingField || declaration.delegate != null) &&
!declaration.hasIgnoredOnParcel() && !declaration.hasIgnoredOnParcel() &&
!containingClassSymbol.hasCustomParceler(context.session) !containingClassSymbol.hasCustomParceler(session)
) { ) {
reporter.reportOn(declaration.source, KtErrorsParcelize.PROPERTY_WONT_BE_SERIALIZED, context) 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 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) reporter.reportOn(declaration.source, KtErrorsParcelize.CREATOR_DEFINITION_IS_NOT_ALLOWED, context)
} }
} }