From 8bf5e867882a85c86541546d83b25236cd7b26b0 Mon Sep 17 00:00:00 2001 From: pyos Date: Sun, 8 Aug 2021 21:00:28 +0200 Subject: [PATCH] FIR/FE: extract common code for handling known nullability annotations --- .../enhancement/EnhancementSignatureParts.kt | 12 ++- .../enhancement/FirJavaEnhancementContext.kt | 13 +-- .../fir/java/enhancement/javaTypeUtils.kt | 8 +- .../fir/java/enhancement/nullabilityUtils.kt | 81 ++---------------- ...AbstractAnnotationTypeQualifierResolver.kt | 38 +++++++++ .../kotlin/load/java/lazy/context.kt | 1 + .../typeEnhancement/signatureEnhancement.kt | 83 +------------------ .../DeserializationComponentsForJava.kt | 6 +- 8 files changed, 64 insertions(+), 178 deletions(-) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt index b2ed4dee93c..2c57296b422 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt @@ -184,8 +184,7 @@ internal class EnhancementSignatureParts( private fun FirTypeRef?.extractQualifiersFromAnnotations( isHeadTypeConstructor: Boolean, - defaultQualifiersForType: JavaDefaultQualifiers?, - javaTypeEnhancementState: JavaTypeEnhancementState + defaultQualifiersForType: JavaDefaultQualifiers? ): JavaTypeQualifiers { val composedAnnotation = if (isHeadTypeConstructor && typeContainer != null) @@ -207,7 +206,7 @@ internal class EnhancementSignatureParts( else defaultQualifiersForType - val nullabilityInfo = composedAnnotation.extractNullability(typeQualifierResolver, javaTypeEnhancementState).also { + val nullabilityInfo = composedAnnotation.extractNullability(typeQualifierResolver).also { if (it?.qualifier == NullabilityQualifier.NOT_NULL) { attributesCache[this] = composedAnnotation.computeTypeAttributesForJavaType() } @@ -242,8 +241,7 @@ internal class EnhancementSignatureParts( session: FirSession, fromSupertypes: Collection, defaultQualifiersForType: JavaDefaultQualifiers?, - isHeadTypeConstructor: Boolean, - javaTypeEnhancementState: JavaTypeEnhancementState + isHeadTypeConstructor: Boolean ): JavaTypeQualifiers { val superQualifiers = fromSupertypes.map { it.extractQualifiers(session) } val mutabilityFromSupertypes = superQualifiers.mapNotNull { it.mutability }.toSet() @@ -252,7 +250,7 @@ internal class EnhancementSignatureParts( .mapNotNull { it.extractQualifiers(session).nullability } .toSet() - val own = extractQualifiersFromAnnotations(isHeadTypeConstructor, defaultQualifiersForType, javaTypeEnhancementState) + val own = extractQualifiersFromAnnotations(isHeadTypeConstructor, defaultQualifiersForType) val ownNullability = own.takeIf { !it.isNullabilityQualifierForWarning }?.nullability val ownNullabilityForWarning = own.nullability @@ -306,7 +304,7 @@ internal class EnhancementSignatureParts( val verticalSlice = indexedFromSupertypes.mapNotNull { it.getOrNull(index)?.type } // Only the head type constructor is safely co-variant - type.computeQualifiersForOverride(session, verticalSlice, defaultQualifiers, isHeadTypeConstructor, javaTypeEnhancementState) + type.computeQualifiersForOverride(session, verticalSlice, defaultQualifiers, isHeadTypeConstructor) } return IndexedJavaTypeQualifiers(computedResult) 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 bee68f07cb9..b8c00db9834 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 @@ -21,7 +21,6 @@ class FirJavaEnhancementContext private constructor( fun extractDefaultNullabilityQualifier( typeQualifierResolver: FirAnnotationTypeQualifierResolver, - javaTypeEnhancementState: JavaTypeEnhancementState, annotationCall: FirAnnotationCall ): JavaDefaultQualifiers? { typeQualifierResolver.resolveQualifierBuiltInDefaultAnnotation(annotationCall)?.let { return it } @@ -38,10 +37,8 @@ fun extractDefaultNullabilityQualifier( return null } - val nullabilityQualifier = typeQualifier.extractNullability( - typeQualifierResolver, javaTypeEnhancementState - )?.copy(isForWarningOnly = jsr305ReportLevel.isWarning) ?: return null - + val nullabilityQualifier = typeQualifier.extractNullability(typeQualifierResolver) + ?.copy(isForWarningOnly = jsr305ReportLevel.isWarning) ?: return null return JavaDefaultQualifiers(nullabilityQualifier, applicability) } @@ -54,11 +51,7 @@ fun FirJavaEnhancementContext.computeNewDefaultTypeQualifiers( val defaultQualifiers = additionalAnnotations.mapNotNull { annotationCall -> - extractDefaultNullabilityQualifier( - typeQualifierResolver, - javaTypeEnhancementState, - annotationCall - ) + extractDefaultNullabilityQualifier(typeQualifierResolver, annotationCall) } if (defaultQualifiers.isEmpty()) return defaultTypeQualifiers diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index 32e71f99fce..a86517de507 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildStarProjection import org.jetbrains.kotlin.fir.types.builder.buildTypeProjectionWithVariance import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef -import org.jetbrains.kotlin.load.java.JavaDefaultQualifiers +import org.jetbrains.kotlin.load.java.* import org.jetbrains.kotlin.load.java.structure.JavaClassifierType import org.jetbrains.kotlin.load.java.structure.JavaType import org.jetbrains.kotlin.load.java.typeEnhancement.* @@ -355,3 +355,9 @@ internal fun List.computeTypeAttributesForJavaType(): ConeAtt -> add(CompilerConeAttributes.EnhancedNullability) } } + +private val NOT_NULL_ANNOTATION_IDS = NOT_NULL_ANNOTATIONS.map { ClassId.topLevel(it) } +private val JAVAX_NONNULL_ANNOTATION_ID = ClassId.topLevel(JAVAX_NONNULL_ANNOTATION) +private val JAVAX_CHECKFORNULL_ANNOTATION_ID = ClassId.topLevel(JAVAX_CHECKFORNULL_ANNOTATION) +private val COMPATQUAL_NONNULL_ANNOTATION_ID = ClassId.topLevel(COMPATQUAL_NONNULL_ANNOTATION) +private val ANDROIDX_RECENTLY_NON_NULL_ANNOTATION_ID = ClassId.topLevel(ANDROIDX_RECENTLY_NON_NULL_ANNOTATION) 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 3afec978696..9790eff05d0 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 @@ -6,86 +6,15 @@ package org.jetbrains.kotlin.fir.java.enhancement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.expressions.arguments -import org.jetbrains.kotlin.fir.expressions.classId -import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol -import org.jetbrains.kotlin.load.java.* -import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifier import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus -import org.jetbrains.kotlin.name.ClassId fun List.extractNullability( - annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver, - javaTypeEnhancementState: JavaTypeEnhancementState + annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver ): NullabilityQualifierWithMigrationStatus? = - this.firstNotNullOfOrNull { annotationCall -> - annotationCall.extractNullability(annotationTypeQualifierResolver, javaTypeEnhancementState) - } + this.firstNotNullOfOrNull { it.extractNullability(annotationTypeQualifierResolver) } fun FirAnnotationCall.extractNullability( - annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver, - javaTypeEnhancementState: JavaTypeEnhancementState -): NullabilityQualifierWithMigrationStatus? { - this.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState)?.let { return it } - - val typeQualifierAnnotation = - annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(this) - ?: return null - - val jsr305ReportLevel = annotationTypeQualifierResolver.resolveJsr305AnnotationState(this) - if (jsr305ReportLevel.isIgnore) return null - - return typeQualifierAnnotation.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState)?.copy(isForWarningOnly = jsr305ReportLevel.isWarning) -} - -private fun FirAnnotationCall.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState: JavaTypeEnhancementState): NullabilityQualifierWithMigrationStatus? { - val annotationClassId = classId ?: return null - val reportLevel = javaTypeEnhancementState.getReportLevelForAnnotation(annotationClassId.asSingleFqName()) - - if (reportLevel == ReportLevel.IGNORE) return null - - return when (annotationClassId) { - in NULLABLE_ANNOTATION_IDS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, reportLevel.isWarning) - in NOT_NULL_ANNOTATION_IDS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, reportLevel.isWarning) - JSPECIFY_NULLABLE_ANNOTATION_ID -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, reportLevel.isWarning) - JSPECIFY_NULLNESS_UNKNOWN_ANNOTATION_ID -> - NullabilityQualifierWithMigrationStatus(NullabilityQualifier.FORCE_FLEXIBILITY, reportLevel.isWarning) - JAVAX_NONNULL_ANNOTATION_ID -> extractNullabilityTypeFromArgument() - COMPATQUAL_NULLABLE_ANNOTATION_ID -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, reportLevel.isWarning) - COMPATQUAL_NONNULL_ANNOTATION_ID -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, reportLevel.isWarning) - ANDROIDX_RECENTLY_NON_NULL_ANNOTATION_ID -> NullabilityQualifierWithMigrationStatus( - NullabilityQualifier.NOT_NULL, - isForWarningOnly = reportLevel.isWarning - ) - ANDROIDX_RECENTLY_NULLABLE_ANNOTATION_ID -> NullabilityQualifierWithMigrationStatus( - NullabilityQualifier.NULLABLE, - isForWarningOnly = reportLevel.isWarning - ) - else -> null - } -} - -private fun FirAnnotationCall.extractNullabilityTypeFromArgument(): NullabilityQualifierWithMigrationStatus? { - val enumValue = this.arguments.firstOrNull()?.toResolvedCallableSymbol()?.callableId?.callableName - // if no argument is specified, use default value: NOT_NULL - ?: return NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL) - - return when (enumValue.asString()) { - "ALWAYS" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL) - "MAYBE", "NEVER" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE) - "UNKNOWN" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.FORCE_FLEXIBILITY) - else -> null - } -} - -private val NULLABLE_ANNOTATION_IDS = NULLABLE_ANNOTATIONS.map { ClassId.topLevel(it) } -val NOT_NULL_ANNOTATION_IDS = NOT_NULL_ANNOTATIONS.map { ClassId.topLevel(it) } -val JAVAX_NONNULL_ANNOTATION_ID = ClassId.topLevel(JAVAX_NONNULL_ANNOTATION) -val JAVAX_CHECKFORNULL_ANNOTATION_ID = ClassId.topLevel(JAVAX_CHECKFORNULL_ANNOTATION) -private val COMPATQUAL_NULLABLE_ANNOTATION_ID = ClassId.topLevel(COMPATQUAL_NULLABLE_ANNOTATION) -val COMPATQUAL_NONNULL_ANNOTATION_ID = ClassId.topLevel(COMPATQUAL_NONNULL_ANNOTATION) -val ANDROIDX_RECENTLY_NON_NULL_ANNOTATION_ID = ClassId.topLevel(ANDROIDX_RECENTLY_NON_NULL_ANNOTATION) -private val ANDROIDX_RECENTLY_NULLABLE_ANNOTATION_ID = ClassId.topLevel(ANDROIDX_RECENTLY_NULLABLE_ANNOTATION) -private val JSPECIFY_NULLABLE_ANNOTATION_ID = ClassId.topLevel(JSPECIFY_NULLABLE) -private val JSPECIFY_NULLNESS_UNKNOWN_ANNOTATION_ID = ClassId.topLevel(JSPECIFY_NULLNESS_UNKNOWN) \ No newline at end of file + annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver +): NullabilityQualifierWithMigrationStatus? = + annotationTypeQualifierResolver.extractNullability(this) { false } 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 index 3e46cc800a9..7721993c736 100644 --- 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 @@ -7,6 +7,8 @@ package org.jetbrains.kotlin.load.java import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifier +import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus import org.jetbrains.kotlin.name.FqName import java.util.concurrent.ConcurrentHashMap @@ -102,6 +104,42 @@ abstract class AbstractAnnotationTypeQualifierResolver( } } + fun extractNullability(annotation: Annotation, forceWarning: Annotation.() -> Boolean): NullabilityQualifierWithMigrationStatus? { + knownNullability(annotation, annotation.forceWarning())?.let { return it } + + val typeQualifierAnnotation = resolveTypeQualifierAnnotation(annotation) ?: return null + val jsr305State = resolveJsr305AnnotationState(annotation) + if (jsr305State.isIgnore) return null + // TODO: the result of `forceWarning` will be overwritten - expected? Probably not. + return knownNullability(typeQualifierAnnotation, typeQualifierAnnotation.forceWarning()) + ?.copy(isForWarningOnly = jsr305State.isWarning) + } + + private fun knownNullability(annotation: Annotation, forceWarning: Boolean): NullabilityQualifierWithMigrationStatus? { + val fqName = annotation.fqName ?: return null + val reportLevel = javaTypeEnhancementState.getReportLevelForAnnotation(fqName) + if (reportLevel.isIgnore) return null + val nullability = when (fqName) { + in NULLABLE_ANNOTATIONS -> NullabilityQualifier.NULLABLE + in NOT_NULL_ANNOTATIONS -> NullabilityQualifier.NOT_NULL + JSPECIFY_NULLABLE -> NullabilityQualifier.NULLABLE + JSPECIFY_NULLNESS_UNKNOWN -> NullabilityQualifier.FORCE_FLEXIBILITY + JAVAX_NONNULL_ANNOTATION -> + when (annotation.enumArguments(onlyValue = false).firstOrNull()) { + "ALWAYS", null -> NullabilityQualifier.NOT_NULL + "MAYBE", "NEVER" -> NullabilityQualifier.NULLABLE + "UNKNOWN" -> NullabilityQualifier.FORCE_FLEXIBILITY + else -> return null + } + COMPATQUAL_NULLABLE_ANNOTATION -> NullabilityQualifier.NULLABLE + COMPATQUAL_NONNULL_ANNOTATION -> NullabilityQualifier.NOT_NULL + ANDROIDX_RECENTLY_NON_NULL_ANNOTATION -> NullabilityQualifier.NOT_NULL + ANDROIDX_RECENTLY_NULLABLE_ANNOTATION -> NullabilityQualifier.NULLABLE + else -> return null + } + return NullabilityQualifierWithMigrationStatus(nullability, reportLevel.isWarning || forceWarning) + } + @OptIn(ExperimentalStdlibApi::class) private companion object { val JAVA_APPLICABILITY_TYPES = buildMap { diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt index 28aeb40f7be..e5d534af7c9 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt @@ -173,6 +173,7 @@ private fun LazyJavaResolverContext.extractDefaultNullabilityQualifier( val areImprovementsInStrictMode = components.settings.typeEnhancementImprovementsInStrictMode + // TODO: if `extractNullability` forces a warning for compatibility, this overrides that. Expected? Probably not. val nullabilityQualifier = components.signatureEnhancement.extractNullability(typeQualifier, areImprovementsInStrictMode, typeParameterBounds = false) ?.copy(isForWarningOnly = jsr305State.isWarning) ?: return null diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 9f7d550949b..49388106294 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -35,9 +35,7 @@ import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents import org.jetbrains.kotlin.load.kotlin.computeJvmDescriptor import org.jetbrains.kotlin.load.kotlin.signature import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.resolve.constants.EnumValue import org.jetbrains.kotlin.resolve.deprecation.DEPRECATED_FUNCTION_KEY -import org.jetbrains.kotlin.resolve.descriptorUtil.firstArgument import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.checker.KotlinTypeChecker @@ -47,90 +45,17 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs class SignatureEnhancement( private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver, - private val javaTypeEnhancementState: JavaTypeEnhancementState, private val typeEnhancement: JavaTypeEnhancement ) { - - private fun AnnotationDescriptor.extractNullabilityTypeFromArgument(isForWarningOnly: Boolean): NullabilityQualifierWithMigrationStatus? { - val enumValue = firstArgument() as? EnumValue - // if no argument is specified, use default value: NOT_NULL - ?: return NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarningOnly) - - return when (enumValue.enumEntryName.asString()) { - "ALWAYS" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarningOnly) - "MAYBE", "NEVER" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarningOnly) - "UNKNOWN" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.FORCE_FLEXIBILITY, isForWarningOnly) - else -> null - } - } - fun extractNullability( annotationDescriptor: AnnotationDescriptor, areImprovementsEnabled: Boolean, typeParameterBounds: Boolean - ): NullabilityQualifierWithMigrationStatus? { - extractNullabilityFromKnownAnnotations(annotationDescriptor, areImprovementsEnabled, typeParameterBounds)?.let { return it } - - val typeQualifierAnnotation = - annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(annotationDescriptor) - ?: return null - - val jsr305State = annotationTypeQualifierResolver.resolveJsr305AnnotationState(annotationDescriptor) - if (jsr305State.isIgnore) return null - - return extractNullabilityFromKnownAnnotations(typeQualifierAnnotation, areImprovementsEnabled, typeParameterBounds) - ?.copy(isForWarningOnly = jsr305State.isWarning) - } - - private fun extractNullabilityFromKnownAnnotations( - annotationDescriptor: AnnotationDescriptor, - areImprovementsEnabled: Boolean, - typeParameterBounds: Boolean - ): NullabilityQualifierWithMigrationStatus? { - val annotationFqName = annotationDescriptor.fqName ?: return null - val isForWarningOnly = annotationDescriptor is LazyJavaAnnotationDescriptor - && (annotationDescriptor.isFreshlySupportedTypeUseAnnotation || typeParameterBounds) - && !areImprovementsEnabled - val migrationStatus = commonMigrationStatus(annotationFqName, annotationDescriptor, isForWarningOnly) ?: return null - - return if (!migrationStatus.isForWarningOnly - && annotationDescriptor is PossiblyExternalAnnotationDescriptor - && annotationDescriptor.isIdeExternalAnnotation - ) { - migrationStatus.copy(isForWarningOnly = true) - } else migrationStatus - } - - private fun commonMigrationStatus( - annotationFqName: FqName, - annotationDescriptor: AnnotationDescriptor, - isForWarningOnly: Boolean = false - ): NullabilityQualifierWithMigrationStatus? { - val reportLevel = javaTypeEnhancementState.getReportLevelForAnnotation(annotationFqName) - - if (reportLevel.isIgnore) return null - - val isForWarning = reportLevel.isWarning || isForWarningOnly - - return when (annotationFqName) { - in NULLABLE_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarning) - in NOT_NULL_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarning) - JSPECIFY_NULLABLE -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarning) - JSPECIFY_NULLNESS_UNKNOWN -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.FORCE_FLEXIBILITY, isForWarning) - JAVAX_NONNULL_ANNOTATION -> annotationDescriptor.extractNullabilityTypeFromArgument(isForWarning) - COMPATQUAL_NULLABLE_ANNOTATION -> - NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarning) - COMPATQUAL_NONNULL_ANNOTATION -> - NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarning) - ANDROIDX_RECENTLY_NON_NULL_ANNOTATION -> NullabilityQualifierWithMigrationStatus( - NullabilityQualifier.NOT_NULL, isForWarning - ) - ANDROIDX_RECENTLY_NULLABLE_ANNOTATION -> NullabilityQualifierWithMigrationStatus( - NullabilityQualifier.NULLABLE, isForWarning - ) - else -> null + ): NullabilityQualifierWithMigrationStatus? = + annotationTypeQualifierResolver.extractNullability(annotationDescriptor) { + (this is LazyJavaAnnotationDescriptor && (isFreshlySupportedTypeUseAnnotation || typeParameterBounds) && !areImprovementsEnabled) || + (this is PossiblyExternalAnnotationDescriptor && isIdeExternalAnnotation) } - } fun enhanceSignatures(c: LazyJavaResolverContext, platformSignatures: Collection): Collection { return platformSignatures.map { 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 18718c1d29f..31450d3efb9 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 @@ -163,11 +163,7 @@ fun makeLazyJavaPackageFragmentProvider( JavaPropertyInitializerEvaluator.DoNothing, SamConversionResolverImpl(storageManager, emptyList()), javaSourceElementFactory, singleModuleClassResolver, packagePartProvider, SupertypeLoopChecker.EMPTY, LookupTracker.DO_NOTHING, module, ReflectionTypes(module, notFoundClasses), annotationTypeQualifierResolver, - SignatureEnhancement( - annotationTypeQualifierResolver, - JavaTypeEnhancementState.DEFAULT, - JavaTypeEnhancement(JavaResolverSettings.Default) - ), + SignatureEnhancement(annotationTypeQualifierResolver, JavaTypeEnhancement(JavaResolverSettings.Default)), JavaClassesTracker.Default, JavaResolverSettings.Default, NewKotlinTypeChecker.Default, javaTypeEnhancementState, object : JavaModuleAnnotationsProvider { override fun getAnnotationsForModuleOwnerOfClass(classId: ClassId): List? = null