FE: do not enhance ? into ? extends @NotNull Object in JSR-305

This is already done in jspecify and makes more sense anyway.

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

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<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>): kotlin.Unit
+    public open fun bar(/*0*/ l: test.L<*, kotlin.Int>): kotlin.Unit
     public open fun baz1(): test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>
-    public open fun baz2(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>
+    public open fun baz2(): test.L<*, kotlin.Int>
     public open fun baz3(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, kotlin.Int>
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open fun foo(/*0*/ l: test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @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<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>): kotlin.Unit
+        public open fun bar(/*0*/ l: test.L<*, kotlin.Int>): kotlin.Unit
         public open fun baz1(): test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>
-        public open fun baz2(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String!, *>, kotlin.Int>
+        public open fun baz2(): test.L<*, kotlin.Int>
         public open fun baz3(): test.L<out kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, kotlin.Int>
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
         public open fun foo(/*0*/ l: test.L<kotlin.collections.(Mutable)Map<kotlin.String, kotlin.Int>, @spr.Nullable kotlin.Int?>): kotlin.Unit
@@ -69,3 +69,4 @@ package test {
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }
 }
+

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<AnnotationQualifierApplicabilityType>,
-    val affectsTypeParameterBasedTypes: Boolean = nullabilityQualifier.qualifier == NullabilityQualifier.NOT_NULL,
+    val affectsTypeParameterBasedTypes: Boolean = nullabilityQualifier.qualifier == NullabilityQualifier.NOT_NULL
-    val affectsStarProjection: Boolean = affectsTypeParameterBasedTypes
 )
 
 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,
+        affectsTypeParameterBasedTypes = false
-        affectsStarProjection = false
     )
 )
 

core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt

@@ -104,7 +104,7 @@ abstract class AbstractSignatureParts<TAnnotation : Any> {
             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<TAnnotation : Any> {
         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<TAnnotation : Any> {
                     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(

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 {

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 &&
+        realNullability == NullabilityQualifier.NOT_NULL && (definitelyNotNull || superQualifiers.any { it.definitelyNotNull }),
-                (isNotNullTypeParameter || superQualifiers.any { it.isNotNullTypeParameter }),
         realNullability != null && newNullabilityForErrors != newNullability
     )
 }

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 {

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)
     }