From f793afbfeaba9623546880d2ffa0ee5b2cb9a6c2 Mon Sep 17 00:00:00 2001 From: pyos Date: Tue, 7 Sep 2021 11:17:30 +0200 Subject: [PATCH] FE: do not enhance `?` into `? extends @NotNull Object` in JSR-305 This is already done in jspecify and makes more sense anyway. --- .../kotlin/fir/java/enhancement/javaTypeUtils.kt | 2 +- .../java8Tests/jsr305/typeArguments.txt | 9 +++++---- .../kotlin/load/java/AnnotationQualifiersFqNames.kt | 6 ++---- .../load/java/typeEnhancement/AbstractSignatureParts.kt | 7 +++---- .../java/typeEnhancement/predefinedEnhancementInfo.kt | 6 +++--- .../load/java/typeEnhancement/typeEnhancementUtils.kt | 3 +-- .../kotlin/load/java/typeEnhancement/typeQualifiers.kt | 4 ++-- .../kotlin/load/java/typeEnhancement/typeEnhancement.kt | 5 +---- 8 files changed, 18 insertions(+), 24 deletions(-) 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 6ab2bd2256b..087aeaf937c 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 @@ -143,7 +143,7 @@ private fun ConeKotlinType.enhanceInflexibleType( val mergedArguments = Array(typeArguments.size) { enhancedArguments[it] ?: typeArguments[it] } val mergedAttributes = if (shouldAddAttribute) attributes + CompilerConeAttributes.EnhancedNullability else attributes val enhancedType = enhancedTag.constructType(mergedArguments, enhancedNullability, mergedAttributes) - return if (effectiveQualifiers.isNotNullTypeParameter) + return if (effectiveQualifiers.definitelyNotNull) ConeDefinitelyNotNullType.create(enhancedType, session.typeContext) ?: enhancedType else enhancedType diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.txt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.txt index 789cdd418b7..4f1c92b35ce 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.txt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.txt @@ -2,9 +2,9 @@ package test public open class A { public constructor A() - public open fun bar(/*0*/ l: test.L, kotlin.Int>): kotlin.Unit + public open fun bar(/*0*/ l: test.L<*, kotlin.Int>): kotlin.Unit public open fun baz1(): test.L, @spr.Nullable kotlin.Int?> - public open fun baz2(): test.L, kotlin.Int> + public open fun baz2(): test.L<*, kotlin.Int> public open fun baz3(): test.L, kotlin.Int> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open fun foo(/*0*/ l: test.L, @spr.Nullable kotlin.Int?>): kotlin.Unit @@ -48,9 +48,9 @@ package test { public open class A { public constructor A() - public open fun bar(/*0*/ l: test.L, kotlin.Int>): kotlin.Unit + public open fun bar(/*0*/ l: test.L<*, kotlin.Int>): kotlin.Unit public open fun baz1(): test.L, @spr.Nullable kotlin.Int?> - public open fun baz2(): test.L, kotlin.Int> + public open fun baz2(): test.L<*, kotlin.Int> public open fun baz3(): test.L, kotlin.Int> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open fun foo(/*0*/ l: test.L, @spr.Nullable kotlin.Int?>): kotlin.Unit @@ -69,3 +69,4 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifiersFqNames.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifiersFqNames.kt index f7da8df1c39..288b28e5242 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifiersFqNames.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifiersFqNames.kt @@ -12,8 +12,7 @@ import org.jetbrains.kotlin.name.FqName data class JavaDefaultQualifiers( val nullabilityQualifier: NullabilityQualifierWithMigrationStatus, val qualifierApplicabilityTypes: Collection, - val affectsTypeParameterBasedTypes: Boolean = nullabilityQualifier.qualifier == NullabilityQualifier.NOT_NULL, - val affectsStarProjection: Boolean = affectsTypeParameterBasedTypes + val affectsTypeParameterBasedTypes: Boolean = nullabilityQualifier.qualifier == NullabilityQualifier.NOT_NULL ) val TYPE_QUALIFIER_NICKNAME_FQNAME = FqName("javax.annotation.meta.TypeQualifierNickname") @@ -34,8 +33,7 @@ val JSPECIFY_DEFAULT_ANNOTATIONS = mapOf( JSPECIFY_NULL_MARKED to JavaDefaultQualifiers( NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL), DEFAULT_JSPECIFY_APPLICABILITY, - affectsTypeParameterBasedTypes = false, - affectsStarProjection = false + affectsTypeParameterBasedTypes = false ) ) diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt index 8894dd9546e..c0cea008a83 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt @@ -104,7 +104,7 @@ abstract class AbstractSignatureParts { else -> AnnotationQualifierApplicabilityType.TYPE_USE } val defaultTypeQualifier = defaultQualifiers?.get(applicabilityType) - ?.takeIf { (it.affectsTypeParameterBasedTypes || typeParameterUse == null) && (it.affectsStarProjection || type != null) } + ?.takeIf { (it.affectsTypeParameterBasedTypes || typeParameterUse == null) } val referencedParameterBoundsNullability = typeParameterUse?.boundsNullability // For type parameter uses, we have *three* options: @@ -120,7 +120,7 @@ abstract class AbstractSignatureParts { val defaultNullability = referencedParameterBoundsNullability?.copy(qualifier = NullabilityQualifier.NOT_NULL) ?: defaultTypeQualifier?.nullabilityQualifier - val isNotNullTypeParameter = + val definitelyNotNull = referencedParameterBoundsNullability?.qualifier == NullabilityQualifier.NOT_NULL || (typeParameterUse != null && defaultTypeQualifier?.nullabilityQualifier?.qualifier == NullabilityQualifier.NOT_NULL) @@ -134,10 +134,9 @@ abstract class AbstractSignatureParts { substitutedParameterBoundsNullability.copy(qualifier = NullabilityQualifier.FORCE_FLEXIBILITY) else substitutedParameterBoundsNullability - type == null -> substitutedParameterBoundsNullability else -> mostSpecific(substitutedParameterBoundsNullability, defaultNullability) } - return JavaTypeQualifiers(result?.qualifier, annotationsMutability, isNotNullTypeParameter, result?.isForWarningOnly == true) + return JavaTypeQualifiers(result?.qualifier, annotationsMutability, definitelyNotNull, result?.isForWarningOnly == true) } private fun mostSpecific( diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/predefinedEnhancementInfo.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/predefinedEnhancementInfo.kt index b31e4a663e1..01ab572aa54 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/predefinedEnhancementInfo.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/predefinedEnhancementInfo.kt @@ -31,11 +31,11 @@ class PredefinedFunctionEnhancementInfo( ) /** Type is always nullable: `T?` */ -private val NULLABLE = JavaTypeQualifiers(NullabilityQualifier.NULLABLE, null, isNotNullTypeParameter = false) +private val NULLABLE = JavaTypeQualifiers(NullabilityQualifier.NULLABLE, null, definitelyNotNull = false) /** Nullability depends on substitution, but the type is not platform: `T` */ -private val NOT_PLATFORM = JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, isNotNullTypeParameter = false) +private val NOT_PLATFORM = JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, definitelyNotNull = false) /** Type is always non-nullable: `T & Any` */ -private val NOT_NULLABLE = JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, isNotNullTypeParameter = true) +private val NOT_NULLABLE = JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, definitelyNotNull = true) @Suppress("LocalVariableName") val PREDEFINED_FUNCTION_ENHANCEMENT_INFO_BY_SIGNATURE = signatures { diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancementUtils.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancementUtils.kt index f47bd507bd2..ed192ab9c6c 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancementUtils.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancementUtils.kt @@ -48,8 +48,7 @@ fun JavaTypeQualifiers.computeQualifiersForOverride( val realNullability = newNullability?.takeUnless { isForVarargParameter && it == NullabilityQualifier.NULLABLE } return JavaTypeQualifiers( realNullability, newMutability, - realNullability == NullabilityQualifier.NOT_NULL && - (isNotNullTypeParameter || superQualifiers.any { it.isNotNullTypeParameter }), + realNullability == NullabilityQualifier.NOT_NULL && (definitelyNotNull || superQualifiers.any { it.definitelyNotNull }), realNullability != null && newNullabilityForErrors != newNullability ) } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt index 4670c5b2cd8..0879b05383f 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeQualifiers.kt @@ -16,10 +16,10 @@ enum class MutabilityQualifier { MUTABLE } -class JavaTypeQualifiers( +class JavaTypeQualifiers constructor( val nullability: NullabilityQualifier?, val mutability: MutabilityQualifier?, - val isNotNullTypeParameter: Boolean, + val definitelyNotNull: Boolean, val isNullabilityQualifierForWarning: Boolean = false ) { companion object { diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt index 6eb25f7ac8e..b16b5048867 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt @@ -37,7 +37,6 @@ import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext import org.jetbrains.kotlin.types.TypeRefinement import org.jetbrains.kotlin.types.typeUtil.createProjection import org.jetbrains.kotlin.types.typeUtil.isTypeParameter -import org.jetbrains.kotlin.types.typeUtil.makeNotNullable fun KotlinType.hasEnhancedNullability(): Boolean = SimpleClassicTypeSystemContext.hasEnhancedNullability(this) @@ -105,7 +104,6 @@ class JavaTypeEnhancement(private val javaResolverSettings: JavaResolverSettings ): SimpleResult { val shouldEnhance = position.shouldEnhance() val shouldEnhanceArguments = !isSuperTypesEnhancement || !isBoundOfRawType - val shouldEnhanceStar = !isBoundOfRawType if (!shouldEnhance && arguments.isEmpty()) return SimpleResult(null, 1, false) val originalClass = constructor.declarationDescriptor @@ -121,7 +119,6 @@ class JavaTypeEnhancement(private val javaResolverSettings: JavaResolverSettings val enhanced = when { !shouldEnhanceArguments -> Result(null, 0) !arg.isStarProjection -> arg.type.unwrap().enhancePossiblyFlexible(qualifiers, globalArgIndex, isSuperTypesEnhancement) - shouldEnhanceStar && qualifiers(globalArgIndex).nullability == NOT_NULL -> Result(arg.type.unwrap().makeNotNullable(), 1) else -> Result(null, 1) } globalArgIndex += enhanced.subtreeSize @@ -150,7 +147,7 @@ class JavaTypeEnhancement(private val javaResolverSettings: JavaResolverSettings enhancedNullability ?: isMarkedNullable ) - val enhancement = if (effectiveQualifiers.isNotNullTypeParameter) notNullTypeParameter(enhancedType) else enhancedType + val enhancement = if (effectiveQualifiers.definitelyNotNull) notNullTypeParameter(enhancedType) else enhancedType val nullabilityForWarning = enhancedNullability != null && effectiveQualifiers.isNullabilityQualifierForWarning return SimpleResult(enhancement, subtreeSize, nullabilityForWarning) }