From 9349d4b0d2d9994caf05981f79569755c223323c Mon Sep 17 00:00:00 2001 From: pyos Date: Sun, 8 Aug 2021 20:31:13 +0200 Subject: [PATCH] FIR/FE: extract common AnnotationTypeQualifierResolver code TODO: extract the equivalent code that uses it... --- .../FirAnnotationTypeQualifierResolver.kt | 163 +++--------------- .../enhancement/FirJavaEnhancementContext.kt | 4 +- .../fir/java/enhancement/nullabilityUtils.kt | 2 +- ...AbstractAnnotationTypeQualifierResolver.kt | 113 ++++++++++++ .../java/AnnotationTypeQualifierResolver.kt | 114 ++---------- .../DeserializationComponentsForJava.kt | 2 +- 6 files changed, 148 insertions(+), 250 deletions(-) create mode 100644 core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt index 6058fffdeeb..dd082602236 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt @@ -5,161 +5,38 @@ package org.jetbrains.kotlin.fir.java.enhancement -import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol -import org.jetbrains.kotlin.load.java.* +import org.jetbrains.kotlin.load.java.AbstractAnnotationTypeQualifierResolver import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME -import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.load.java.JavaTypeEnhancementState -import org.jetbrains.kotlin.load.java.ReportLevel import org.jetbrains.kotlin.name.FqName -class FirAnnotationTypeQualifierResolver(private val session: FirSession, private val javaTypeEnhancementState: JavaTypeEnhancementState) { +@Suppress("EXTENSION_SHADOWED_BY_MEMBER") +class FirAnnotationTypeQualifierResolver(private val session: FirSession, javaTypeEnhancementState: JavaTypeEnhancementState) : + AbstractAnnotationTypeQualifierResolver(javaTypeEnhancementState) +{ + override val FirAnnotationCall.annotations: Iterable + get() = coneClassLikeType?.lookupTag?.toSymbol(session)?.fir?.annotations.orEmpty() - class TypeQualifierWithApplicability( - private val typeQualifier: FirAnnotationCall, - private val applicability: Int - ) { - operator fun component1() = typeQualifier - operator fun component2() = AnnotationQualifierApplicabilityType.values().filter(this::isApplicableTo) + override val FirAnnotationCall.key: Any + get() = coneClassLikeType!!.lookupTag - private fun isApplicableTo(elementType: AnnotationQualifierApplicabilityType) = - isApplicableConsideringMask(AnnotationQualifierApplicabilityType.TYPE_USE) || isApplicableConsideringMask( - elementType - ) + override val FirAnnotationCall.fqName: FqName? + get() = coneClassLikeType?.lookupTag?.classId?.asSingleFqName() - private fun isApplicableConsideringMask(elementType: AnnotationQualifierApplicabilityType) = - (applicability and (1 shl elementType.ordinal)) != 0 - } - - // TODO: memoize this function - private fun computeTypeQualifierNickname(klass: FirRegularClass): FirAnnotationCall? { - if (klass.annotations.none { it.classId == TYPE_QUALIFIER_NICKNAME_ID }) return null - - return klass.annotations.firstNotNullOfOrNull(this::resolveTypeQualifierAnnotation) - } - - private fun resolveTypeQualifierNickname(klass: FirRegularClass): FirAnnotationCall? { - if (klass.classKind != ClassKind.ANNOTATION_CLASS) return null - - return computeTypeQualifierNickname(klass) - } - - private val FirAnnotationCall.resolvedClass: FirRegularClass? - get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirRegularClassSymbol)?.fir - - fun resolveTypeQualifierAnnotation(annotationCall: FirAnnotationCall): FirAnnotationCall? { - if (javaTypeEnhancementState.jsr305.isDisabled) { - return null + override fun FirAnnotationCall.enumArguments(onlyValue: Boolean): Iterable = + arguments.flatMap { argument -> + if (!onlyValue || argument !is FirNamedArgumentExpression || argument.name == DEFAULT_ANNOTATION_MEMBER_NAME) + argument.toEnumNames() + else + emptyList() } - val annotationClass = annotationCall.resolvedClass ?: return null - if (annotationClass.isAnnotatedWithTypeQualifier) return annotationCall - - return resolveTypeQualifierNickname(annotationClass) - } - - fun resolveQualifierBuiltInDefaultAnnotation(annotationCall: FirAnnotationCall): JavaDefaultQualifiers? { - if (javaTypeEnhancementState.jsr305.isDisabled) { - return null - } - - val annotationClassId = annotationCall.classId - return BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATION_IDS[annotationClassId]?.let { qualifierForDefaultingAnnotation -> - val state = resolveJsr305ReportLevel(annotationCall).takeIf { it != ReportLevel.IGNORE } ?: return null - qualifierForDefaultingAnnotation.copy( - nullabilityQualifier = qualifierForDefaultingAnnotation.nullabilityQualifier.copy(isForWarningOnly = state.isWarning) - ) - } - } - - fun resolveTypeQualifierDefaultAnnotation(annotationCall: FirAnnotationCall): TypeQualifierWithApplicability? { - if (javaTypeEnhancementState.jsr305.isDisabled) { - return null - } - - val typeQualifierDefaultAnnotatedClass = - annotationCall.resolvedClass?.takeIf { klass -> - klass.annotations.any { it.classId == TYPE_QUALIFIER_DEFAULT_ID } - } ?: return null - - val elementTypesMask = - annotationCall.resolvedClass!! - .annotations.find { it.classId == TYPE_QUALIFIER_DEFAULT_ID }!! - .arguments - .flatMap { argument -> - if (argument !is FirNamedArgumentExpression || argument.name == DEFAULT_ANNOTATION_MEMBER_NAME) - argument.mapConstantToQualifierApplicabilityTypes() - else - emptyList() - } - .fold(0) { acc: Int, applicabilityType -> acc or (1 shl applicabilityType.ordinal) } - - val typeQualifier = typeQualifierDefaultAnnotatedClass.annotations.firstOrNull { resolveTypeQualifierAnnotation(it) != null } - ?: return null - - return TypeQualifierWithApplicability( - typeQualifier, - elementTypesMask - ) - } - - fun resolveJsr305ReportLevel(annotationCall: FirAnnotationCall): ReportLevel { - resolveJsr305CustomLevel(annotationCall)?.let { return it } - return javaTypeEnhancementState.jsr305.globalLevel - } - - fun resolveJsr305CustomLevel(annotationCall: FirAnnotationCall): ReportLevel? { - javaTypeEnhancementState.jsr305.userDefinedLevelForSpecificAnnotation[annotationCall.classId?.run { FqName(packageFqName.asString() + "." + relativeClassName.asString()) }]?.let { return it } - return annotationCall.resolvedClass?.migrationAnnotationStatus() - } - - private fun FirRegularClass.migrationAnnotationStatus(): ReportLevel? { - val enumEntryName = annotations.find { - it.classId == MIGRATION_ANNOTATION_ID - }?.arguments?.firstOrNull()?.toResolvedCallableSymbol()?.callableId?.callableName ?: return null - - javaTypeEnhancementState.jsr305.migrationLevel?.let { return it } - - return when (enumEntryName.asString()) { - "STRICT" -> ReportLevel.STRICT - "WARN" -> ReportLevel.WARN - "IGNORE" -> ReportLevel.IGNORE - else -> null - } - } - - private fun FirExpression.mapConstantToQualifierApplicabilityTypes(): List = + private fun FirExpression.toEnumNames(): List = when (this) { - is FirArrayOfCall -> arguments.flatMap { it.mapConstantToQualifierApplicabilityTypes() } - else -> listOfNotNull( - when (toResolvedCallableSymbol()?.callableId?.callableName?.asString()) { - "METHOD" -> AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE - "FIELD" -> AnnotationQualifierApplicabilityType.FIELD - "PARAMETER" -> AnnotationQualifierApplicabilityType.VALUE_PARAMETER - "TYPE_USE" -> AnnotationQualifierApplicabilityType.TYPE_USE - else -> null - } - ) + is FirArrayOfCall -> arguments.flatMap { it.toEnumNames() } + else -> listOfNotNull(toResolvedCallableSymbol()?.callableId?.callableName?.asString()) } - - val isDisabled: Boolean = javaTypeEnhancementState.jsr305.isDisabled - } - -private val FirRegularClass.isAnnotatedWithTypeQualifier: Boolean - get() = this.symbol.classId in BUILT_IN_TYPE_QUALIFIER_IDS || - annotations.any { it.classId == TYPE_QUALIFIER_ID } - -private val TYPE_QUALIFIER_ID = ClassId.topLevel(TYPE_QUALIFIER_FQNAME) -private val BUILT_IN_TYPE_QUALIFIER_IDS = BUILT_IN_TYPE_QUALIFIER_FQ_NAMES.map { ClassId.topLevel(it) } -private val TYPE_QUALIFIER_DEFAULT_ID = ClassId.topLevel(TYPE_QUALIFIER_DEFAULT_FQNAME) -private val MIGRATION_ANNOTATION_ID = ClassId.topLevel(MIGRATION_ANNOTATION_FQNAME) -private val TYPE_QUALIFIER_NICKNAME_ID = ClassId.topLevel(TYPE_QUALIFIER_NICKNAME_FQNAME) - -private val BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATION_IDS = - BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATIONS.mapKeys { ClassId.topLevel(it.key) } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt index 2b0157237cd..bee68f07cb9 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt @@ -31,7 +31,7 @@ fun extractDefaultNullabilityQualifier( ?: return null val jsr305ReportLevel = with(typeQualifierResolver) { - resolveJsr305CustomLevel(annotationCall) ?: resolveJsr305ReportLevel(typeQualifier) + resolveJsr305CustomState(annotationCall) ?: resolveJsr305AnnotationState(typeQualifier) } if (jsr305ReportLevel.isIgnore) { @@ -50,7 +50,7 @@ fun FirJavaEnhancementContext.computeNewDefaultTypeQualifiers( javaTypeEnhancementState: JavaTypeEnhancementState, additionalAnnotations: List ): JavaTypeQualifiersByElementType? { - if (typeQualifierResolver.isDisabled) return defaultTypeQualifiers + if (javaTypeEnhancementState.jsr305.isDisabled) return defaultTypeQualifiers val defaultQualifiers = additionalAnnotations.mapNotNull { annotationCall -> diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt index 79b62228850..3afec978696 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt @@ -33,7 +33,7 @@ fun FirAnnotationCall.extractNullability( annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(this) ?: return null - val jsr305ReportLevel = annotationTypeQualifierResolver.resolveJsr305ReportLevel(this) + val jsr305ReportLevel = annotationTypeQualifierResolver.resolveJsr305AnnotationState(this) if (jsr305ReportLevel.isIgnore) return null return typeQualifierAnnotation.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState)?.copy(isForWarningOnly = jsr305ReportLevel.isWarning) diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt new file mode 100644 index 00000000000..3e46cc800a9 --- /dev/null +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt @@ -0,0 +1,113 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.load.java + +import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.name.FqName +import java.util.concurrent.ConcurrentHashMap + +typealias TypeQualifierWithApplicability = Pair> + +abstract class AbstractAnnotationTypeQualifierResolver( + private val javaTypeEnhancementState: JavaTypeEnhancementState +) { + protected abstract val Annotation.annotations: Iterable + protected abstract val Annotation.key: Any // TODO: figure out if keying `resolvedNicknames` by `fqName` is safe + protected abstract val Annotation.fqName: FqName? + protected abstract fun Annotation.enumArguments(onlyValue: Boolean): Iterable + + private fun Annotation.findAnnotation(fqName: FqName): Annotation? = + annotations.find { it.fqName == fqName } + + private fun Annotation.hasAnnotation(fqName: FqName): Boolean = + annotations.any { it.fqName == fqName } + + private val resolvedNicknames = ConcurrentHashMap() + + fun resolveTypeQualifierAnnotation(annotation: Annotation): Annotation? { + if (javaTypeEnhancementState.jsr305.isDisabled) return null + if (annotation.fqName in BUILT_IN_TYPE_QUALIFIER_FQ_NAMES || annotation.hasAnnotation(TYPE_QUALIFIER_FQNAME)) + return annotation + if (!annotation.hasAnnotation(TYPE_QUALIFIER_NICKNAME_FQNAME)) + return null + return resolvedNicknames.getOrPut(annotation.key) { + // This won't store nulls (ConcurrentHashMap does not permit that), but presumably unless the code + // is broken a nickname should be resolvable. + annotation.annotations.firstNotNullOfOrNull(::resolveTypeQualifierAnnotation) ?: return null + } + } + + fun resolveQualifierBuiltInDefaultAnnotation(annotation: Annotation): JavaDefaultQualifiers? { + if (javaTypeEnhancementState.disabledDefaultAnnotations) { + return null + } + + return BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATIONS[annotation.fqName]?.let { qualifierForDefaultingAnnotation -> + val state = resolveDefaultAnnotationState(annotation).takeIf { it != ReportLevel.IGNORE } ?: return null + qualifierForDefaultingAnnotation.copy( + nullabilityQualifier = qualifierForDefaultingAnnotation.nullabilityQualifier.copy(isForWarningOnly = state.isWarning) + ) + } + } + + private fun resolveDefaultAnnotationState(annotation: Annotation): ReportLevel { + val annotationFqname = annotation.fqName + if (annotationFqname != null && annotationFqname in JSPECIFY_DEFAULT_ANNOTATIONS) { + return javaTypeEnhancementState.getReportLevelForAnnotation(annotationFqname) + } + return resolveJsr305AnnotationState(annotation) + } + + // We explicitly state that while JSR-305 TYPE_USE annotations effectively should be applied to every type. + // They are not applicable for type parameter bounds because it would be a breaking change otherwise. + private fun Set.allIfTypeUse(): Set = + if (AnnotationQualifierApplicabilityType.TYPE_USE in this) + AnnotationQualifierApplicabilityType.values().toSet() - AnnotationQualifierApplicabilityType.TYPE_PARAMETER_BOUNDS + this + else + this + + fun resolveTypeQualifierDefaultAnnotation(annotation: Annotation): TypeQualifierWithApplicability? { + if (javaTypeEnhancementState.jsr305.isDisabled) return null + val typeQualifierDefault = annotation.findAnnotation(TYPE_QUALIFIER_DEFAULT_FQNAME) ?: return null + val typeQualifier = annotation.annotations.firstOrNull { resolveTypeQualifierAnnotation(it) != null } ?: return null + val applicability = typeQualifierDefault.enumArguments(onlyValue = true) + .mapNotNullTo(mutableSetOf()) { JAVA_APPLICABILITY_TYPES[it] } + return TypeQualifierWithApplicability(typeQualifier, applicability.allIfTypeUse()) + } + + fun isTypeUseAnnotation(annotation: Annotation): Boolean { + // Expect that Java's Target was mapped to Kotlin's Target. + val target = annotation.findAnnotation(StandardNames.FqNames.target) ?: return false + return target.enumArguments(onlyValue = false).any { it == KotlinTarget.TYPE.name } + } + + fun resolveJsr305AnnotationState(annotation: Annotation): ReportLevel { + resolveJsr305CustomState(annotation)?.let { return it } + return javaTypeEnhancementState.jsr305.globalLevel + } + + fun resolveJsr305CustomState(annotation: Annotation): ReportLevel? { + javaTypeEnhancementState.jsr305.userDefinedLevelForSpecificAnnotation[annotation.fqName]?.let { return it } + val enumValue = annotation.findAnnotation(MIGRATION_ANNOTATION_FQNAME)?.enumArguments(onlyValue = false)?.firstOrNull() + ?: return null + return javaTypeEnhancementState.jsr305.migrationLevel ?: when (enumValue) { + "STRICT" -> ReportLevel.STRICT + "WARN" -> ReportLevel.WARN + "IGNORE" -> ReportLevel.IGNORE + else -> null + } + } + + @OptIn(ExperimentalStdlibApi::class) + private companion object { + val JAVA_APPLICABILITY_TYPES = buildMap { + for (type in AnnotationQualifierApplicabilityType.values()) { + getOrPut(type.javaTarget) { type } + } + } + } +} diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt index 47f4e31092e..805a9798ff3 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt @@ -16,102 +16,27 @@ package org.jetbrains.kotlin.load.java -import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor -import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget -import org.jetbrains.kotlin.load.java.components.JavaAnnotationTargetMapper +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.EnumValue import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass -import org.jetbrains.kotlin.storage.StorageManager -typealias TypeQualifierWithApplicability = Pair> +@Suppress("EXTENSION_SHADOWED_BY_MEMBER") +class AnnotationTypeQualifierResolver(javaTypeEnhancementState: JavaTypeEnhancementState) : + AbstractAnnotationTypeQualifierResolver(javaTypeEnhancementState) { -class AnnotationTypeQualifierResolver(storageManager: StorageManager, private val javaTypeEnhancementState: JavaTypeEnhancementState) { - private val resolvedNicknames = - storageManager.createMemoizedFunctionWithNullableValues { klass: ClassDescriptor -> - if (klass.annotations.hasAnnotation(TYPE_QUALIFIER_NICKNAME_FQNAME)) - klass.annotations.firstNotNullOfOrNull(this::resolveTypeQualifierAnnotation) - else - null - } + override val AnnotationDescriptor.annotations: Iterable + get() = annotationClass?.annotations ?: emptyList() - fun resolveTypeQualifierAnnotation(annotation: AnnotationDescriptor): AnnotationDescriptor? { - if (javaTypeEnhancementState.jsr305.isDisabled) return null - val annotationClass = annotation.annotationClass ?: return null - if (annotation.fqName in BUILT_IN_TYPE_QUALIFIER_FQ_NAMES || annotationClass.annotations.hasAnnotation(TYPE_QUALIFIER_FQNAME)) - return annotation - return resolvedNicknames(annotationClass) - } + override val AnnotationDescriptor.key: Any + get() = annotationClass!! - fun resolveQualifierBuiltInDefaultAnnotation(annotation: AnnotationDescriptor): JavaDefaultQualifiers? { - if (javaTypeEnhancementState.disabledDefaultAnnotations) { - return null - } + override val AnnotationDescriptor.fqName: FqName? + get() = fqName - return BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATIONS[annotation.fqName]?.let { qualifierForDefaultingAnnotation -> - val state = resolveDefaultAnnotationState(annotation).takeIf { it != ReportLevel.IGNORE } ?: return null - qualifierForDefaultingAnnotation.copy( - nullabilityQualifier = qualifierForDefaultingAnnotation.nullabilityQualifier.copy(isForWarningOnly = state.isWarning) - ) - } - } - - private fun resolveDefaultAnnotationState(annotation: AnnotationDescriptor): ReportLevel { - val annotationFqname = annotation.fqName - if (annotationFqname != null && annotationFqname in JSPECIFY_DEFAULT_ANNOTATIONS) { - return javaTypeEnhancementState.getReportLevelForAnnotation(annotationFqname) - } - return resolveJsr305AnnotationState(annotation) - } - - // We explicitly state that while JSR-305 TYPE_USE annotations effectively should be applied to every type. - // They are not applicable for type parameter bounds because it would be a breaking change otherwise. - private fun Set.allIfTypeUse(): Set = - if (AnnotationQualifierApplicabilityType.TYPE_USE in this) - AnnotationQualifierApplicabilityType.values().toSet() - AnnotationQualifierApplicabilityType.TYPE_PARAMETER_BOUNDS + this - else - this - - fun resolveTypeQualifierDefaultAnnotation(annotation: AnnotationDescriptor): TypeQualifierWithApplicability? { - if (javaTypeEnhancementState.jsr305.isDisabled) return null - val annotationClass = annotation.annotationClass ?: return null - val typeQualifierDefault = annotationClass.annotations.findAnnotation(TYPE_QUALIFIER_DEFAULT_FQNAME) ?: return null - val typeQualifier = annotationClass.annotations.firstOrNull { resolveTypeQualifierAnnotation(it) != null } ?: return null - val applicability = typeQualifierDefault.enumArguments(onlyValue = true) - .mapNotNullTo(mutableSetOf()) { JAVA_APPLICABILITY_TYPES[it] } - return TypeQualifierWithApplicability(typeQualifier, applicability.allIfTypeUse()) - } - - fun isTypeUseAnnotation(annotation: AnnotationDescriptor): Boolean { - val annotatedClass = annotation.annotationClass ?: return false - val target = annotatedClass.annotations.findAnnotation(JvmAnnotationNames.TARGET_ANNOTATION) ?: return false - return target.enumArguments(onlyValue = false).any { it == KotlinTarget.TYPE.name } - } - - fun resolveJsr305AnnotationState(annotation: AnnotationDescriptor): ReportLevel { - resolveJsr305CustomState(annotation)?.let { return it } - return javaTypeEnhancementState.jsr305.globalLevel - } - - fun resolveJsr305CustomState(annotation: AnnotationDescriptor): ReportLevel? { - javaTypeEnhancementState.jsr305.userDefinedLevelForSpecificAnnotation[annotation.fqName]?.let { return it } - return annotation.annotationClass?.migrationAnnotationStatus() - } - - private fun ClassDescriptor.migrationAnnotationStatus(): ReportLevel? { - val enumValue = annotations.findAnnotation(MIGRATION_ANNOTATION_FQNAME)?.enumArguments(onlyValue = false)?.firstOrNull() - ?: return null - return javaTypeEnhancementState.jsr305.migrationLevel ?: when (enumValue) { - "STRICT" -> ReportLevel.STRICT - "WARN" -> ReportLevel.WARN - "IGNORE" -> ReportLevel.IGNORE - else -> null - } - } - - private fun AnnotationDescriptor.enumArguments(onlyValue: Boolean): Iterable = + override fun AnnotationDescriptor.enumArguments(onlyValue: Boolean): Iterable = allValueArguments.flatMap { (parameter, argument) -> if (!onlyValue || parameter == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME) argument.toEnumNames() @@ -125,21 +50,4 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va is EnumValue -> listOf(enumEntryName.identifier) else -> emptyList() } - - @OptIn(ExperimentalStdlibApi::class) - private companion object { - val JAVA_APPLICABILITY_TYPES = buildMap { - for (type in AnnotationQualifierApplicabilityType.values()) { - getOrPut(type.javaTarget) { type } - } - } - - val KOTLIN_APPLICABILITY_TYPES = buildMap { - for (type in AnnotationQualifierApplicabilityType.values()) { - for (target in JavaAnnotationTargetMapper.mapJavaTargetArgumentByName(type.javaTarget)) { - getOrPut(target.name) { type } - } - } - } - } } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/DeserializationComponentsForJava.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/DeserializationComponentsForJava.kt index 226e0cd5d8a..18718c1d29f 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/DeserializationComponentsForJava.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/DeserializationComponentsForJava.kt @@ -155,7 +155,7 @@ fun makeLazyJavaPackageFragmentProvider( singleModuleClassResolver: ModuleClassResolver, packagePartProvider: PackagePartProvider = PackagePartProvider.Empty ): LazyJavaPackageFragmentProvider { - val annotationTypeQualifierResolver = AnnotationTypeQualifierResolver(storageManager, JavaTypeEnhancementState.DEFAULT) + val annotationTypeQualifierResolver = AnnotationTypeQualifierResolver(JavaTypeEnhancementState.DEFAULT) val javaTypeEnhancementState = JavaTypeEnhancementState.DEFAULT val javaResolverComponents = JavaResolverComponents( storageManager, javaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver,