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

[FIR] Rename JvmNames -> JvmStandardClassIds

Browse Source 
This is more consistent with the code of
the common compiler checkers.

It would be nice to refactor the contents
of this object further, but it's out
of scope of the current branch.

^KT-54596
This commit is contained in:
Nikolay Lunyak
2023-08-10 18:01:51 +03:00
committed by Space Team
parent 986f1624ec
commit ec9cb8beb6
59 changed files with 136 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationHelper.kt
+2 -2
View File
@@ -15,13 +15,13 @@ import org.jetbrains.kotlin.fir.isNewPlaceForBodyGeneration
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.SymbolInternals
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
fun <D> FirBasedSymbol<out D>.isCompiledToJvmDefault(
session: FirSession,
jvmDefaultMode: JvmDefaultMode,
): Boolean where D : FirAnnotationContainer, D : FirDeclaration {
if (getAnnotationByClassId(JvmNames.Annotations.JvmDefault, session) != null) return true
if (getAnnotationByClassId(JvmStandardClassIds.Annotations.JvmDefault, session) != null) return true
val container = getContainingClassSymbol(session)
if (container !is FirRegularClassSymbol || container.origin.fromSource) return jvmDefaultMode.forAllMethodsWithBody
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmAnnotationsPlatformSpecificSupportComponent.kt
+9 -9
View File
@@ -15,39 +15,39 @@ import org.jetbrains.kotlin.fir.declarations.FirAnnotationsPlatformSpecificSuppo
import org.jetbrains.kotlin.fir.expressions.FirAnnotation
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds
object FirJvmAnnotationsPlatformSpecificSupportComponent : FirAnnotationsPlatformSpecificSupportComponent() {
override val requiredAnnotationsWithArguments: Set<ClassId> = setOf(
StandardClassIds.Annotations.Deprecated,
StandardClassIds.Annotations.Target,
JvmNames.Annotations.Java.Target,
JvmStandardClassIds.Annotations.Java.Target,
)
override val requiredAnnotations: Set<ClassId> = requiredAnnotationsWithArguments + setOf(
JvmNames.Annotations.Java.Deprecated,
JvmStandardClassIds.Annotations.Java.Deprecated,
StandardClassIds.Annotations.DeprecatedSinceKotlin,
StandardClassIds.Annotations.SinceKotlin,
StandardClassIds.Annotations.WasExperimental,
JvmNames.Annotations.JvmRecord,
JvmStandardClassIds.Annotations.JvmRecord,
)
override val volatileAnnotations: Set<ClassId> = setOf(
StandardClassIds.Annotations.Volatile,
JvmNames.Annotations.JvmVolatile,
JvmStandardClassIds.Annotations.JvmVolatile,
)
override val deprecationAnnotationsWithOverridesPropagation: Map<ClassId, Boolean> = mapOf(
StandardClassIds.Annotations.Deprecated to true,
JvmNames.Annotations.Java.Deprecated to false,
JvmStandardClassIds.Annotations.Java.Deprecated to false,
StandardClassIds.Annotations.SinceKotlin to true,
)
override fun symbolContainsRepeatableAnnotation(symbol: FirClassLikeSymbol<*>, session: FirSession): Boolean {
if (symbol.getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session) != null) return true
if (symbol.getAnnotationByClassId(JvmNames.Annotations.Java.Repeatable, session) != null ||
symbol.getAnnotationByClassId(JvmNames.Annotations.JvmRepeatable, session) != null
if (symbol.getAnnotationByClassId(JvmStandardClassIds.Annotations.Java.Repeatable, session) != null ||
symbol.getAnnotationByClassId(JvmStandardClassIds.Annotations.JvmRepeatable, session) != null
) {
return session.languageVersionSettings.supportsFeature(LanguageFeature.RepeatableAnnotations) ||
symbol.getAnnotationRetention(session) == AnnotationRetention.SOURCE && symbol.origin is FirDeclarationOrigin.Java
@@ -64,7 +64,7 @@ object FirJvmAnnotationsPlatformSpecificSupportComponent : FirAnnotationsPlatfor
if (propertyAnnotations.isEmpty() || property.backingField == null) return null
val (newBackingFieldAnnotations, newPropertyAnnotations) = propertyAnnotations.partition {
it.toAnnotationClassIdSafe(session) == JvmNames.Annotations.Java.Deprecated
it.toAnnotationClassIdSafe(session) == JvmStandardClassIds.Annotations.Java.Deprecated
}
if (newBackingFieldAnnotations.isEmpty()) return null
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmPrimaryConstructorSuperTypeCheckerPlatformComponent.kt
+2 -2
View File
@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.fir.analysis.jvm.checkers
import org.jetbrains.kotlin.fir.analysis.checkers.FirPrimaryConstructorSuperTypeCheckerPlatformComponent
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds
object FirJvmPrimaryConstructorSuperTypeCheckerPlatformComponent : FirPrimaryConstructorSuperTypeCheckerPlatformComponent() {
override val supertypesThatDontNeedInitializationInSubtypesConstructors: Set<ClassId> =
setOf(StandardClassIds.Enum, JvmNames.Java.Record)
setOf(StandardClassIds.Enum, JvmStandardClassIds.Java.Record)
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmDefaultChecker.kt
+2 -2
View File
@@ -16,8 +16,8 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.fir.declarations.utils.isInterface
import org.jetbrains.kotlin.fir.java.jvmDefaultModeState
import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID
import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_DEFAULT_NO_COMPATIBILITY_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_DEFAULT_WITH_COMPATIBILITY_CLASS_ID
object FirJvmDefaultChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmFieldApplicabilityChecker.kt
+1 -1
View File
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.fir.types.classId
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.JvmNames.JVM_MULTIFILE_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_MULTIFILE_CLASS_ID
import org.jetbrains.kotlin.name.StandardClassIds
object FirJvmFieldApplicabilityChecker : FirPropertyChecker() {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt
+2 -2
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.resolve.getContainingClass
import org.jetbrains.kotlin.fir.types.classId
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.resolvedType
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
@@ -59,7 +59,7 @@ object FirJvmNameChecker : FirBasicDeclarationChecker() {
private fun FirDeclaration.findJvmNameAnnotation(): FirAnnotation? {
return annotations.firstOrNull {
it.annotationTypeRef.coneType.classId == JvmNames.Annotations.JvmName
it.annotationTypeRef.coneType.classId == JvmStandardClassIds.Annotations.JvmName
}
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRecordChecker.kt
+3 -3
View File
@@ -24,14 +24,14 @@ import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.classId
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmNames.JVM_RECORD_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_RECORD_ANNOTATION_CLASS_ID
object FirJvmRecordChecker : FirRegularClassChecker() {
override fun check(declaration: FirRegularClass, context: CheckerContext, reporter: DiagnosticReporter) {
declaration.superTypeRefs.firstOrNull()?.let { typeRef ->
// compiler automatically adds java.lang.Record supertype, so we should check only for explicit type declarations
if (typeRef.source != null && typeRef.coneTypeSafe<ConeClassLikeType>()?.fullyExpandedClassId(context.session) == JvmNames.Java.Record) {
if (typeRef.source != null && typeRef.coneTypeSafe<ConeClassLikeType>()?.fullyExpandedClassId(context.session) == JvmStandardClassIds.Java.Record) {
reporter.reportOn(typeRef.source, FirJvmErrors.ILLEGAL_JAVA_LANG_RECORD_SUPERTYPE, context)
return
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmRedundantRepeatableChecker.kt
+3 -3
View File
@@ -13,15 +13,15 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.unexpandedClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds.Annotations.Repeatable
import org.jetbrains.kotlin.name.JvmNames.Annotations.JvmRepeatable
import org.jetbrains.kotlin.name.JvmStandardClassIds.Annotations.JvmRepeatable
object FirJvmRedundantRepeatableChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
val kotlinRepeatable = declaration.getAnnotationByClassId(Repeatable, context.session)
val javaRepeatable = declaration.getAnnotationByClassId(JvmRepeatable, context.session)
?: declaration.getAnnotationByClassId(JvmNames.Annotations.Java.Repeatable, context.session)
?: declaration.getAnnotationByClassId(JvmStandardClassIds.Annotations.Java.Repeatable, context.session)
if (kotlinRepeatable != null && javaRepeatable != null) {
reporter.reportOn(
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmStaticChecker.kt
+4 -5
View File
@@ -28,9 +28,8 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.name.StandardClassIds
object FirJvmStaticChecker : FirBasicDeclarationChecker() {
override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -43,14 +42,14 @@ object FirJvmStaticChecker : FirBasicDeclarationChecker() {
return
}
val declarationAnnotation = declaration.findAnnotation(JvmNames.Annotations.JvmStatic, context.session)
val declarationAnnotation = declaration.findAnnotation(JvmStandardClassIds.Annotations.JvmStatic, context.session)
if (declarationAnnotation != null) {
checkAnnotated(declaration, context, reporter, declaration.source)
}
fun checkIfAnnotated(it: FirDeclaration) {
if (!it.hasAnnotation(JvmNames.Annotations.JvmStatic, context.session)) {
if (!it.hasAnnotation(JvmStandardClassIds.Annotations.JvmStatic, context.session)) {
return
}
val targetSource = it.source ?: declaration.source
@@ -202,7 +201,7 @@ object FirJvmStaticChecker : FirBasicDeclarationChecker() {
targetSource: KtSourceElement?,
) {
if (declaration !is FirProperty) return
if (declaration.isConst || declaration.backingField?.hasAnnotationNamedAs(JvmNames.Annotations.JvmField, context.session) == true) {
if (declaration.isConst || declaration.backingField?.hasAnnotationNamedAs(JvmStandardClassIds.Annotations.JvmField, context.session) == true) {
reporter.reportOn(targetSource, FirJvmErrors.JVM_STATIC_ON_CONST_OR_JVM_FIELD, context)
}
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmSyntheticApplicabilityChecker.kt
+1 -1
View File
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.name.JvmNames.JVM_SYNTHETIC_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_SYNTHETIC_ANNOTATION_CLASS_ID
object FirJvmSyntheticApplicabilityChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirOverloadsChecker.kt
+1 -1
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isActual
import org.jetbrains.kotlin.fir.declarations.utils.isLocal
import org.jetbrains.kotlin.fir.declarations.utils.visibility
import org.jetbrains.kotlin.fir.resolve.dfa.cfg.isLocalClassOrAnonymousObject
import org.jetbrains.kotlin.name.JvmNames.JVM_OVERLOADS_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_OVERLOADS_CLASS_ID
object FirOverloadsChecker : FirFunctionChecker() {
override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirRepeatableAnnotationChecker.kt
+3 -3
View File
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.load.java.JvmAbi
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.StandardClassIds
@@ -83,7 +83,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
}
if (declaration is FirRegularClass) {
val javaRepeatable = annotations.getAnnotationByClassId(JvmNames.Annotations.Java.Repeatable, session)
val javaRepeatable = annotations.getAnnotationByClassId(JvmStandardClassIds.Annotations.Java.Repeatable, session)
if (javaRepeatable != null) {
checkJavaRepeatableAnnotationDeclaration(javaRepeatable, declaration, context, reporter)
} else {
@@ -97,7 +97,7 @@ object FirRepeatableAnnotationChecker : FirBasicDeclarationChecker() {
private fun FirClassLikeSymbol<*>.resolveContainerAnnotation(session: FirSession): ClassId? {
val repeatableAnnotation = getAnnotationByClassId(StandardClassIds.Annotations.Repeatable, session)
?: getAnnotationByClassId(JvmNames.Annotations.Java.Repeatable, session)
?: getAnnotationByClassId(JvmStandardClassIds.Annotations.Java.Repeatable, session)
?: return null
return repeatableAnnotation.resolveContainerAnnotation()
}
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirStrictfpApplicabilityChecker.kt
+1 -1
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
import org.jetbrains.kotlin.diagnostics.reportOn
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.STRICTFP_ANNOTATION_CLASS_ID
object FirStrictfpApplicabilityChecker : FirClassChecker() {
override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirSynchronizedAnnotationChecker.kt
+1 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInline
import org.jetbrains.kotlin.fir.declarations.utils.isSuspend
import org.jetbrains.kotlin.fir.types.coneType
import org.jetbrains.kotlin.fir.types.isSuspendOrKSuspendFunctionType
import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.SYNCHRONIZED_ANNOTATION_CLASS_ID
object FirSynchronizedAnnotationChecker : FirFunctionChecker() {
override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/expression/FirJavaAnnotationsChecker.kt
+5 -5
View File
@@ -26,17 +26,17 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
import org.jetbrains.kotlin.fir.types.ConeClassLikeType
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds.Annotations
object FirJavaAnnotationsChecker : FirAnnotationChecker() {
private val javaToKotlinNameMap: Map<ClassId, ClassId> =
mapOf(
JvmNames.Annotations.Java.Target to Annotations.Target,
JvmNames.Annotations.Java.Retention to Annotations.Retention,
JvmNames.Annotations.Java.Deprecated to Annotations.Deprecated,
JvmNames.Annotations.Java.Documented to Annotations.MustBeDocumented,
JvmStandardClassIds.Annotations.Java.Target to Annotations.Target,
JvmStandardClassIds.Annotations.Java.Retention to Annotations.Retention,
JvmStandardClassIds.Annotations.Java.Deprecated to Annotations.Deprecated,
JvmStandardClassIds.Annotations.Java.Documented to Annotations.MustBeDocumented,
)
override fun check(expression: FirAnnotation, context: CheckerContext, reporter: DiagnosticReporter) {
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/DelegatedMemberGenerator.kt
+1 -1
View File
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
import org.jetbrains.kotlin.ir.util.SYNTHETIC_OFFSET
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.JvmNames.JVM_DEFAULT_CLASS_ID
import org.jetbrains.kotlin.name.JvmStandardClassIds.JVM_DEFAULT_CLASS_ID
import org.jetbrains.kotlin.name.Name
/**
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+2 -2
View File
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.load.java.structure.JavaModifierListOwner
import org.jetbrains.kotlin.load.java.structure.JavaWildcardType
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.types.ConstantValueKind
internal val JavaModifierListOwner.modality: Modality
@@ -141,4 +141,4 @@ fun FirProperty.hasJvmFieldAnnotation(session: FirSession): Boolean =
backingField?.annotations?.any { it.isJvmFieldAnnotation(session) } == true
fun FirAnnotation.isJvmFieldAnnotation(session: FirSession): Boolean =
toAnnotationClassId(session) == JvmNames.Annotations.JvmField
toAnnotationClassId(session) == JvmStandardClassIds.Annotations.JvmField
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt
+4 -4
View File
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.JvmStandardClassIds
import org.jetbrains.kotlin.name.StandardClassIds
class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUpdater() {
@@ -33,7 +33,7 @@ class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUp
override fun updateSupertypesIfNeeded(firClass: FirClass, scopeSession: ScopeSession) {
if (firClass !is FirRegularClass || !firClass.isData ||
!firClass.hasAnnotationSafe(JvmNames.Annotations.JvmRecord, session)
!firClass.hasAnnotationSafe(JvmStandardClassIds.Annotations.JvmRecord, session)
) return
var anyFound = false
var hasExplicitSuperClass = false
@@ -62,7 +62,7 @@ class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUp
private class DelegatedConstructorCallTransformer(private val session: FirSession) : FirTransformer<ScopeSession>() {
companion object {
val recordType = JvmNames.Java.Record.constructClassLikeType(emptyArray(), isNullable = false)
val recordType = JvmStandardClassIds.Java.Record.constructClassLikeType(emptyArray(), isNullable = false)
}
override fun <E : FirElement> transformElement(element: E, data: ScopeSession): E {
@@ -104,7 +104,7 @@ class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUp
if (recordConstructorSymbol != null) {
val newReference = buildResolvedNamedReference {
name = JvmNames.Java.Record.shortClassName
name = JvmStandardClassIds.Java.Record.shortClassName
resolvedSymbol = recordConstructorSymbol
}
delegatedConstructorCall.replaceCalleeReference(newReference)
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/JavaCompilerRequiredAnnotationEnhancementProvider.kt
+2 -3
View File
@@ -10,13 +10,12 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
import org.jetbrains.kotlin.fir.resolve.transformers.plugin.CompilerRequiredAnnotationEnhancementProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
import org.jetbrains.kotlin.name.JvmNames
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.name.JvmStandardClassIds
object JavaCompilerRequiredAnnotationEnhancementProvider : CompilerRequiredAnnotationEnhancementProvider() {
override fun enhance(enumSymbol: FirClassSymbol<*>, enumEntrySymbol: FirEnumEntrySymbol, session: FirSession): FirEnumEntrySymbol {
val firRegularClass = enumSymbol.fir as? FirRegularClass ?: return enumEntrySymbol
if (enumSymbol.classId != JvmNames.Annotations.Java.ElementType) return enumEntrySymbol
if (enumSymbol.classId != JvmStandardClassIds.Annotations.Java.ElementType) return enumEntrySymbol
return FirSignatureEnhancement(firRegularClass, session) { emptyList() }.enhancedProperty(
enumEntrySymbol,
compiler/fir/java/src/org/jetbrains/kotlin/fir/java/javaAnnotationsMapping.kt
+7 -7
View File
@@ -257,10 +257,10 @@ internal fun JavaAnnotation.isJavaDeprecatedAnnotation(): Boolean {
private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotation = buildAnnotation {
val lookupTag = when (classId) {
JvmNames.Annotations.Java.Target -> StandardClassIds.Annotations.Target
JvmNames.Annotations.Java.Retention -> StandardClassIds.Annotations.Retention
JvmNames.Annotations.Java.Documented -> StandardClassIds.Annotations.MustBeDocumented
JvmNames.Annotations.Java.Deprecated -> StandardClassIds.Annotations.Deprecated
JvmStandardClassIds.Annotations.Java.Target -> StandardClassIds.Annotations.Target
JvmStandardClassIds.Annotations.Java.Retention -> StandardClassIds.Annotations.Retention
JvmStandardClassIds.Annotations.Java.Documented -> StandardClassIds.Annotations.MustBeDocumented
JvmStandardClassIds.Annotations.Java.Deprecated -> StandardClassIds.Annotations.Deprecated
else -> classId
}?.toLookupTag()
annotationTypeRef = if (lookupTag != null) {
@@ -285,7 +285,7 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
override val mapping: Map<Name, FirExpression> by lazy {
when {
classId == JvmNames.Annotations.Java.Target -> {
classId == JvmStandardClassIds.Annotations.Java.Target -> {
when (val argument = arguments.firstOrNull()) {
is JavaArrayAnnotationArgument -> argument.getElements().mapJavaTargetArguments(session)
is JavaEnumValueAnnotationArgument -> listOf(argument).mapJavaTargetArguments(session)
@@ -295,13 +295,13 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
}
}
classId == JvmNames.Annotations.Java.Retention -> {
classId == JvmStandardClassIds.Annotations.Java.Retention -> {
arguments.firstOrNull()?.mapJavaRetentionArgument(session)?.let {
mapOf(StandardClassIds.Annotations.ParameterNames.retentionValue to it)
}
}
classId == JvmNames.Annotations.Java.Deprecated -> {
classId == JvmStandardClassIds.Annotations.Java.Deprecated -> {
mapOf(
StandardClassIds.Annotations.ParameterNames.deprecatedMessage to "Deprecated in Java".createConstantOrError(
session,