Rename Jsr305State -> JavaTypeEnhancementState

Also, rename some of the properties
It's needed to store status for codeanalysis annotation in that class

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/Jsr305Parser.kt

@@ -18,11 +18,11 @@ package org.jetbrains.kotlin.cli.common.arguments
 
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.ReportLevel
 
 class Jsr305Parser(private val collector: MessageCollector) {
-    fun parse(value: Array<String>?, supportCompatqualCheckerFrameworkAnnotations: String?): Jsr305State {
+    fun parse(value: Array<String>?, supportCompatqualCheckerFrameworkAnnotations: String?): JavaTypeEnhancementState {
         var global: ReportLevel? = null
         var migration: ReportLevel? = null
         val userDefined = mutableMapOf<String, ReportLevel>()
@@ -86,13 +86,13 @@ class Jsr305Parser(private val collector: MessageCollector) {
             }
         }
 
-        val state = Jsr305State(
+        val state = JavaTypeEnhancementState(
             global ?: ReportLevel.WARN, migration, userDefined,
             enableCompatqualCheckerFrameworkAnnotations =
             enableCompatqualCheckerFrameworkAnnotations
-                    ?: Jsr305State.COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE
+                    ?: JavaTypeEnhancementState.COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE
         )
-        return if (state == Jsr305State.DISABLED) Jsr305State.DISABLED else state
+        return if (state == JavaTypeEnhancementState.DISABLED_JSR_305) JavaTypeEnhancementState.DISABLED_JSR_305 else state
     }
 
     private fun reportUnrecognizedJsr305(item: String) {

compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.config
 
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import kotlin.reflect.KProperty
 
 object JvmAnalysisFlags {
@@ -35,8 +35,8 @@ object JvmAnalysisFlags {
 
     private object Delegates {
         object Jsr305StateWarnByDefault {
-            operator fun provideDelegate(instance: Any?, property: KProperty<*>): AnalysisFlag.Delegate<Jsr305State> =
+            operator fun provideDelegate(instance: Any?, property: KProperty<*>): AnalysisFlag.Delegate<JavaTypeEnhancementState> =
-                AnalysisFlag.Delegate(property.name, Jsr305State.DEFAULT)
+                AnalysisFlag.Delegate(property.name, JavaTypeEnhancementState.DEFAULT)
         }
 
         object JvmDefaultModeDisabledByDefault {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt

@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaWildcardType
 import org.jetbrains.kotlin.load.java.typeEnhancement.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqNameUnsafe
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 internal class EnhancementSignatureParts(
@@ -47,11 +47,11 @@ internal class EnhancementSignatureParts(
 
     internal fun enhance(
         session: FirSession,
-        jsr305State: Jsr305State,
+        javaTypeEnhancementState: JavaTypeEnhancementState,
         predefined: TypeEnhancementInfo? = null,
         forAnnotationValueParameter: Boolean = false
     ): PartEnhancementResult {
-        val qualifiers = computeIndexedQualifiersForOverride(session, jsr305State)
+        val qualifiers = computeIndexedQualifiersForOverride(session, javaTypeEnhancementState)
 
         val qualifiersWithPredefined = predefined?.let {
             IndexedJavaTypeQualifiers(qualifiers.size) { index ->
@@ -92,13 +92,13 @@ internal class EnhancementSignatureParts(
 
     private fun FirTypeRef.toIndexed(
         typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-        jsr305State: Jsr305State,
+        javaTypeEnhancementState: JavaTypeEnhancementState,
         context: FirJavaEnhancementContext
     ): List<TypeAndDefaultQualifiers> {
         val list = ArrayList<TypeAndDefaultQualifiers>(1)
 
         fun add(type: FirTypeRef?) {
-            val c = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, type?.annotations.orEmpty())
+            val c = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, javaTypeEnhancementState, type?.annotations.orEmpty())
 
             list.add(
                 TypeAndDefaultQualifiers(
@@ -182,7 +182,7 @@ internal class EnhancementSignatureParts(
     private fun FirTypeRef?.extractQualifiersFromAnnotations(
         isHeadTypeConstructor: Boolean,
         defaultQualifiersForType: JavaDefaultQualifiers?,
-        jsr305State: Jsr305State
+        javaTypeEnhancementState: JavaTypeEnhancementState
     ): JavaTypeQualifiers {
         val composedAnnotation =
             if (isHeadTypeConstructor && typeContainer != null)
@@ -204,7 +204,7 @@ internal class EnhancementSignatureParts(
             else
                 defaultQualifiersForType
 
-        val nullabilityInfo = composedAnnotation.extractNullability(typeQualifierResolver, jsr305State)
+        val nullabilityInfo = composedAnnotation.extractNullability(typeQualifierResolver, javaTypeEnhancementState)
             ?: defaultTypeQualifier?.nullabilityQualifier?.let { nullability ->
                 NullabilityQualifierWithMigrationStatus(
                     nullability.qualifier,
@@ -236,7 +236,7 @@ internal class EnhancementSignatureParts(
         fromSupertypes: Collection<FirTypeRef>,
         defaultQualifiersForType: JavaDefaultQualifiers?,
         isHeadTypeConstructor: Boolean,
-        jsr305State: Jsr305State
+        javaTypeEnhancementState: JavaTypeEnhancementState
     ): JavaTypeQualifiers {
         val superQualifiers = fromSupertypes.map { it.extractQualifiers(session) }
         val mutabilityFromSupertypes = superQualifiers.mapNotNull { it.mutability }.toSet()
@@ -245,7 +245,7 @@ internal class EnhancementSignatureParts(
             .mapNotNull { it.extractQualifiers(session).nullability }
             .toSet()
 
-        val own = extractQualifiersFromAnnotations(isHeadTypeConstructor, defaultQualifiersForType, jsr305State)
+        val own = extractQualifiersFromAnnotations(isHeadTypeConstructor, defaultQualifiersForType, javaTypeEnhancementState)
         val ownNullability = own.takeIf { !it.isNullabilityQualifierForWarning }?.nullability
         val ownNullabilityForWarning = own.nullability
 
@@ -279,9 +279,9 @@ internal class EnhancementSignatureParts(
         )
     }
 
-    private fun computeIndexedQualifiersForOverride(session: FirSession, jsr305State: Jsr305State): IndexedJavaTypeQualifiers {
+    private fun computeIndexedQualifiersForOverride(session: FirSession, javaTypeEnhancementState: JavaTypeEnhancementState): IndexedJavaTypeQualifiers {
-        val indexedFromSupertypes = fromOverridden.map { it.toIndexed(typeQualifierResolver, jsr305State, context) }
+        val indexedFromSupertypes = fromOverridden.map { it.toIndexed(typeQualifierResolver, javaTypeEnhancementState, context) }
-        val indexedThisType = current.toIndexed(typeQualifierResolver, jsr305State, context)
+        val indexedThisType = current.toIndexed(typeQualifierResolver, javaTypeEnhancementState, context)
 
         // The covariant case may be hard, e.g. in the superclass the return may be Super<T>, but in the subclass it may be Derived, which
         // is declared to extend Super<T>, and propagating data here is highly non-trivial, so we only look at the head type constructor
@@ -299,7 +299,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, jsr305State)
+            type.computeQualifiersForOverride(session, verticalSlice, defaultQualifiers, isHeadTypeConstructor, javaTypeEnhancementState)
         }
 
         return IndexedJavaTypeQualifiers(computedResult)

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt

@@ -14,11 +14,11 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.load.java.*
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.ReportLevel
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
-class FirAnnotationTypeQualifierResolver(private val session: FirSession, private val jsr305State: Jsr305State) {
+class FirAnnotationTypeQualifierResolver(private val session: FirSession, private val javaTypeEnhancementState: JavaTypeEnhancementState) {
 
     class TypeQualifierWithApplicability(
         private val typeQualifier: FirAnnotationCall,
@@ -53,7 +53,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
         get() = (coneClassLikeType?.lookupTag?.toSymbol(this@FirAnnotationTypeQualifierResolver.session) as? FirRegularClassSymbol)?.fir
 
     fun resolveTypeQualifierAnnotation(annotationCall: FirAnnotationCall): FirAnnotationCall? {
-        if (jsr305State.disabled) {
+        if (javaTypeEnhancementState.disabledJsr305) {
             return null
         }
 
@@ -64,7 +64,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
     }
 
     fun resolveQualifierBuiltInDefaultAnnotation(annotationCall: FirAnnotationCall): JavaDefaultQualifiers? {
-        if (jsr305State.disabled) {
+        if (javaTypeEnhancementState.disabledJsr305) {
             return null
         }
 
@@ -78,7 +78,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
     }
 
     fun resolveTypeQualifierDefaultAnnotation(annotationCall: FirAnnotationCall): TypeQualifierWithApplicability? {
-        if (jsr305State.disabled) {
+        if (javaTypeEnhancementState.disabledJsr305) {
             return null
         }
 
@@ -110,11 +110,11 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
 
     fun resolveJsr305ReportLevel(annotationCall: FirAnnotationCall): ReportLevel {
         resolveJsr305CustomLevel(annotationCall)?.let { return it }
-        return jsr305State.global
+        return javaTypeEnhancementState.globalJsr305Level
     }
 
     fun resolveJsr305CustomLevel(annotationCall: FirAnnotationCall): ReportLevel? {
-        jsr305State.user[annotationCall.classId?.run { packageFqName.asString() + "." + relativeClassName.asString() }]?.let { return it }
+        javaTypeEnhancementState.userDefinedLevelForSpecificJsr305Annotation[annotationCall.classId?.run { packageFqName.asString() + "." + relativeClassName.asString() }]?.let { return it }
         return annotationCall.resolvedClass?.migrationAnnotationStatus()
     }
 
@@ -123,7 +123,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
             it.classId == MIGRATION_ANNOTATION_ID
         }?.arguments?.firstOrNull()?.toResolvedCallableSymbol()?.callableId?.callableName ?: return null
 
-        jsr305State.migration?.let { return it }
+        javaTypeEnhancementState.migrationLevelForJsr305?.let { return it }
 
         return when (enumEntryName.asString()) {
             "STRICT" -> ReportLevel.STRICT
@@ -147,7 +147,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
             )
         }
 
-    val disabled: Boolean = jsr305State.disabled
+    val disabled: Boolean = javaTypeEnhancementState.disabledJsr305
 
 }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.java.enhancement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.load.java.*
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 
 class FirJavaEnhancementContext private constructor(
     val session: FirSession,
@@ -24,7 +24,7 @@ class FirJavaEnhancementContext private constructor(
 
 fun extractDefaultNullabilityQualifier(
     typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-    jsr305State: Jsr305State,
+    javaTypeEnhancementState: JavaTypeEnhancementState,
     annotationCall: FirAnnotationCall
 ): JavaDefaultQualifiers? {
     typeQualifierResolver.resolveQualifierBuiltInDefaultAnnotation(annotationCall)?.let { return it }
@@ -42,7 +42,7 @@ fun extractDefaultNullabilityQualifier(
     }
 
     val nullabilityQualifier = typeQualifier.extractNullability(
-        typeQualifierResolver, jsr305State
+        typeQualifierResolver, javaTypeEnhancementState
     )?.copy(isForWarningOnly = jsr305ReportLevel.isWarning) ?: return null
 
     return JavaDefaultQualifiers(nullabilityQualifier, applicability)
@@ -50,7 +50,7 @@ fun extractDefaultNullabilityQualifier(
 
 fun FirJavaEnhancementContext.computeNewDefaultTypeQualifiers(
     typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-    jsr305State: Jsr305State,
+    javaTypeEnhancementState: JavaTypeEnhancementState,
     additionalAnnotations: List<FirAnnotationCall>
 ): JavaTypeQualifiersByElementType? {
     if (typeQualifierResolver.disabled) return defaultTypeQualifiers
@@ -59,7 +59,7 @@ fun FirJavaEnhancementContext.computeNewDefaultTypeQualifiers(
         additionalAnnotations.mapNotNull { annotationCall ->
             extractDefaultNullabilityQualifier(
                 typeQualifierResolver,
-                jsr305State,
+                javaTypeEnhancementState,
                 annotationCall
             )
         }
@@ -83,12 +83,12 @@ fun FirJavaEnhancementContext.computeNewDefaultTypeQualifiers(
 
 fun FirJavaEnhancementContext.copyWithNewDefaultTypeQualifiers(
     typeQualifierResolver: FirAnnotationTypeQualifierResolver,
-    jsr305State: Jsr305State,
+    javaTypeEnhancementState: JavaTypeEnhancementState,
     additionalAnnotations: List<FirAnnotationCall>
 ): FirJavaEnhancementContext =
     when {
         additionalAnnotations.isEmpty() -> this
         else -> FirJavaEnhancementContext(session) {
-            computeNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, additionalAnnotations)
+            computeNewDefaultTypeQualifiers(typeQualifierResolver, javaTypeEnhancementState, additionalAnnotations)
         }
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJsr305StateContainer.kt

@@ -7,11 +7,11 @@ package org.jetbrains.kotlin.fir.java.enhancement
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 
-class FirJsr305StateContainer(val jsr305State: Jsr305State) : FirSessionComponent {
+class FirJsr305StateContainer(val javaTypeEnhancementState: JavaTypeEnhancementState) : FirSessionComponent {
     companion object {
-        val Default: FirJsr305StateContainer = FirJsr305StateContainer(Jsr305State.DEFAULT)
+        val Default: FirJsr305StateContainer = FirJsr305StateContainer(JavaTypeEnhancementState.DEFAULT)
     }
 }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue
 import org.jetbrains.kotlin.load.java.typeEnhancement.*
 import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 class FirSignatureEnhancement(
@@ -47,7 +47,7 @@ class FirSignatureEnhancement(
     private val javaTypeParameterStack: JavaTypeParameterStack =
         if (owner is FirJavaClass) owner.javaTypeParameterStack else JavaTypeParameterStack.EMPTY
 
-    private val jsr305State: Jsr305State = session.jsr305StateContainer.jsr305State
+    private val jsr305State: JavaTypeEnhancementState = session.javaTypeEnhancementState ?: JavaTypeEnhancementState.DEFAULT
 
     private val typeQualifierResolver = FirAnnotationTypeQualifierResolver(session, jsr305State)
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt

@@ -13,23 +13,23 @@ 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
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
 fun List<FirAnnotationCall>.extractNullability(
     annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver,
-    jsr305State: Jsr305State
+    javaTypeEnhancementState: JavaTypeEnhancementState
 ): NullabilityQualifierWithMigrationStatus? =
     this.firstNotNullResult { annotationCall ->
-        annotationCall.extractNullability(annotationTypeQualifierResolver, jsr305State)
+        annotationCall.extractNullability(annotationTypeQualifierResolver, javaTypeEnhancementState)
     }
 
 
 fun FirAnnotationCall.extractNullability(
     annotationTypeQualifierResolver: FirAnnotationTypeQualifierResolver,
-    jsr305State: Jsr305State
+    javaTypeEnhancementState: JavaTypeEnhancementState
 ): NullabilityQualifierWithMigrationStatus? {
-    this.extractNullabilityFromKnownAnnotations(jsr305State)?.let { return it }
+    this.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState)?.let { return it }
 
     val typeQualifierAnnotation =
         annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(this)
@@ -38,10 +38,10 @@ fun FirAnnotationCall.extractNullability(
     val jsr305ReportLevel = annotationTypeQualifierResolver.resolveJsr305ReportLevel(this)
     if (jsr305ReportLevel.isIgnore) return null
 
-    return typeQualifierAnnotation.extractNullabilityFromKnownAnnotations(jsr305State)?.copy(isForWarningOnly = jsr305ReportLevel.isWarning)
+    return typeQualifierAnnotation.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState)?.copy(isForWarningOnly = jsr305ReportLevel.isWarning)
 }
 
-private fun FirAnnotationCall.extractNullabilityFromKnownAnnotations(jsr305State: Jsr305State): NullabilityQualifierWithMigrationStatus? {
+private fun FirAnnotationCall.extractNullabilityFromKnownAnnotations(javaTypeEnhancementState: JavaTypeEnhancementState): NullabilityQualifierWithMigrationStatus? {
     val annotationClassId = classId ?: return null
 
     return when {
@@ -49,10 +49,10 @@ private fun FirAnnotationCall.extractNullabilityFromKnownAnnotations(jsr305State
         annotationClassId in NOT_NULL_ANNOTATION_IDS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL)
         annotationClassId == JAVAX_NONNULL_ANNOTATION_ID -> extractNullabilityTypeFromArgument()
 
-        annotationClassId == COMPATQUAL_NULLABLE_ANNOTATION_ID && jsr305State.enableCompatqualCheckerFrameworkAnnotations ->
+        annotationClassId == COMPATQUAL_NULLABLE_ANNOTATION_ID && javaTypeEnhancementState.enableCompatqualCheckerFrameworkAnnotations ->
             NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE)
 
-        annotationClassId == COMPATQUAL_NONNULL_ANNOTATION_ID && jsr305State.enableCompatqualCheckerFrameworkAnnotations ->
+        annotationClassId == COMPATQUAL_NONNULL_ANNOTATION_ID && javaTypeEnhancementState.enableCompatqualCheckerFrameworkAnnotations ->
             NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL)
 
         annotationClassId == ANDROIDX_RECENTLY_NON_NULL_ANNOTATION_ID -> NullabilityQualifierWithMigrationStatus(

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSession.kt

@@ -12,7 +12,8 @@ import org.jetbrains.kotlin.fir.utils.ArrayMapAccessor
 import org.jetbrains.kotlin.fir.utils.ComponentArrayOwner
 import org.jetbrains.kotlin.fir.utils.NullableArrayMapAccessor
 import org.jetbrains.kotlin.fir.utils.TypeRegistry
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
+import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KClass
 
 interface FirSessionComponent
@@ -30,6 +31,8 @@ abstract class FirSession @PrivateSessionConstructor constructor(val sessionProv
 
     open val moduleInfo: ModuleInfo? get() = null
 
+    val javaTypeEnhancementState: JavaTypeEnhancementState? get() = null
+
     open val builtinTypes: BuiltinTypes = BuiltinTypes()
 
     final override val typeRegistry: TypeRegistry<FirSessionComponent, FirSessionComponent> = Companion

compiler/testData/foreignAnnotationsJava8/tests/codeanalysis/wildcardsWithDefault.txt

@@ -13,7 +13,7 @@ public open class B {
     public constructor B()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    @jspecify.annotations.DefaultNotNull public open fun noBoundsNotNull(/*0*/ a: A<out @jspecify.annotations.NotNull kotlin.Any, out @codeanalysis.annotations.Nullable kotlin.Any, out @codeanalysis.annotations.UnknownNullness kotlin.Any>): kotlin.Unit
+    @jspecify.annotations.DefaultNotNull public open fun noBoundsNotNull(/*0*/ a: A<out @jspecify.annotations.NotNull kotlin.Any, out @jspecify.annotations.Nullable kotlin.Any, out @codeanalysis.annotations.UnknownNullness kotlin.Any>): kotlin.Unit
     @jspecify.annotations.DefaultNullable public open fun noBoundsNullable(/*0*/ a: A<out @jspecify.annotations.NotNull kotlin.Any, *, *>?): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.test.TestJdkKind
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.ReportLevel
 import java.io.File
 
@@ -78,7 +78,7 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() {
             name to state
         }.toMap()
 
-        return mapOf(JvmAnalysisFlags.jsr305 to Jsr305State(globalState, migrationState, userAnnotationsState))
+        return mapOf(JvmAnalysisFlags.jsr305 to JavaTypeEnhancementState(globalState, migrationState, userAnnotationsState))
     }
 
     private fun List<TestFile>.getDirectiveValue(directive: String): ReportLevel? = mapNotNull {

compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import java.io.File
 
 class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() {
@@ -47,7 +47,7 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() {
                 put(JVMConfigurationKeys.USE_JAVAC, true)
             }
             languageVersionSettings = LanguageVersionSettingsImpl(
-                    LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.jsr305 to Jsr305State.STRICT)
+                    LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.jsr305 to JavaTypeEnhancementState.STRICT)
             )
             configurator(this)
         }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.MockLibraryUtil
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import java.io.File
 
 class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
@@ -97,7 +97,7 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() {
                 listOf(File(TEST_DATA_PATH))
         ).apply {
             languageVersionSettings = LanguageVersionSettingsImpl(
-                    LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.jsr305 to Jsr305State.STRICT)
+                    LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.jsr305 to JavaTypeEnhancementState.STRICT)
             )
         }
 

compiler/util/build.gradle.kts

@@ -6,6 +6,8 @@ plugins {
 dependencies {
     api(kotlinStdlib())
     api(project(":compiler:compiler.version"))
+    compile(project(":core:deserialization"))
+    compileOnly(project(":kotlin-reflect-api"))
 
     compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     compileOnly(intellijDep()) { includeIntellijCoreJarDependencies(project) }

compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.config
 
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 
@@ -33,6 +34,14 @@ class AnalysisFlag<out T> internal constructor(
             operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, ExplicitApiMode.DISABLED)
         }
 
+        object Jsr305StateWarnByDefault {
+            operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, JavaTypeEnhancementState.DEFAULT)
+        }
+
+        object JvmDefaultModeDisabledByDefault {
+            operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, JvmDefaultMode.DISABLE)
+        }
+
         object ListOfStrings {
             operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, emptyList<String>())
         }

compiler/util/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2020 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.
  */
 

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt

@@ -26,11 +26,11 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.firstArgument
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.ReportLevel
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
-class AnnotationTypeQualifierResolver(storageManager: StorageManager, private val jsr305State: Jsr305State) {
+class AnnotationTypeQualifierResolver(storageManager: StorageManager, private val javaTypeEnhancementState: JavaTypeEnhancementState) {
     class TypeQualifierWithApplicability(
         private val typeQualifier: AnnotationDescriptor,
         private val applicability: Int
@@ -68,7 +68,7 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
     }
 
     fun resolveTypeQualifierAnnotation(annotationDescriptor: AnnotationDescriptor): AnnotationDescriptor? {
-        if (jsr305State.disabled) {
+        if (javaTypeEnhancementState.disabledJsr305) {
             return null
         }
 
@@ -79,7 +79,7 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
     }
 
     fun resolveQualifierBuiltInDefaultAnnotation(annotationDescriptor: AnnotationDescriptor): JavaDefaultQualifiers? {
-        if (jsr305State.disabled) {
+        if (javaTypeEnhancementState.disabledJsr305) {
             return null
         }
 
@@ -92,7 +92,7 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
     }
 
     fun resolveTypeQualifierDefaultAnnotation(annotationDescriptor: AnnotationDescriptor): TypeQualifierWithApplicability? {
-        if (jsr305State.disabled) {
+        if (javaTypeEnhancementState.disabledJsr305) {
             return null
         }
 
@@ -120,11 +120,11 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
 
     fun resolveJsr305AnnotationState(annotationDescriptor: AnnotationDescriptor): ReportLevel {
         resolveJsr305CustomState(annotationDescriptor)?.let { return it }
-        return jsr305State.global
+        return javaTypeEnhancementState.globalJsr305Level
     }
 
     fun resolveJsr305CustomState(annotationDescriptor: AnnotationDescriptor): ReportLevel? {
-        jsr305State.user[annotationDescriptor.fqName?.asString()]?.let { return it }
+        javaTypeEnhancementState.userDefinedLevelForSpecificJsr305Annotation[annotationDescriptor.fqName?.asString()]?.let { return it }
         return annotationDescriptor.annotationClass?.migrationAnnotationStatus()
     }
 
@@ -132,7 +132,7 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
         val enumValue = annotations.findAnnotation(MIGRATION_ANNOTATION_FQNAME)?.firstArgument() as? EnumValue
             ?: return null
 
-        jsr305State.migration?.let { return it }
+        javaTypeEnhancementState.migrationLevelForJsr305?.let { return it }
 
         return when (enumValue.enumEntryName.asString()) {
             "STRICT" -> ReportLevel.STRICT
@@ -157,7 +157,7 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
             else -> emptyList()
         }
 
-    val disabled: Boolean = jsr305State.disabled
+    val disabled: Boolean = javaTypeEnhancementState.disabledJsr305
 }
 
 private val ClassDescriptor.isAnnotatedWithTypeQualifier: Boolean

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt

@@ -40,13 +40,13 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.typeUtil.isTypeParameter
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 class SignatureEnhancement(
     private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver,
-    private val jsr305State: Jsr305State,
+    private val javaTypeEnhancementState: JavaTypeEnhancementState,
     private val typeEnhancement: JavaTypeEnhancement
 ) {
 
@@ -117,10 +117,10 @@ class SignatureEnhancement(
         annotationFqName in NOT_NULL_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL)
         annotationFqName == JAVAX_NONNULL_ANNOTATION -> annotationDescriptor.extractNullabilityTypeFromArgument()
 
-        annotationFqName == COMPATQUAL_NULLABLE_ANNOTATION && jsr305State.enableCompatqualCheckerFrameworkAnnotations ->
+        annotationFqName == COMPATQUAL_NULLABLE_ANNOTATION && javaTypeEnhancementState.enableCompatqualCheckerFrameworkAnnotations ->
             NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE)
 
-        annotationFqName == COMPATQUAL_NONNULL_ANNOTATION && jsr305State.enableCompatqualCheckerFrameworkAnnotations ->
+        annotationFqName == COMPATQUAL_NONNULL_ANNOTATION && javaTypeEnhancementState.enableCompatqualCheckerFrameworkAnnotations ->
             NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL)
 
         annotationFqName == ANDROIDX_RECENTLY_NON_NULL_ANNOTATION -> NullabilityQualifierWithMigrationStatus(

core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/components/RuntimeModuleData.kt

@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfigu
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 
 class RuntimeModuleData private constructor(
     val deserialization: DeserializationComponents,
@@ -110,14 +110,14 @@ fun makeLazyJavaPackageFragmentFromClassLoaderProvider(
     singleModuleClassResolver: ModuleClassResolver,
     packagePartProvider: PackagePartProvider = PackagePartProvider.Empty
 ): LazyJavaPackageFragmentProvider {
-    val annotationTypeQualifierResolver = AnnotationTypeQualifierResolver(storageManager, Jsr305State.DISABLED)
+    val annotationTypeQualifierResolver = AnnotationTypeQualifierResolver(storageManager, JavaTypeEnhancementState.DISABLED_JSR_305)
     val javaResolverComponents = JavaResolverComponents(
         storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
         SignaturePropagator.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY,
         JavaPropertyInitializerEvaluator.DoNothing, SamConversionResolverImpl(storageManager, emptyList()), RuntimeSourceElementFactory,
         singleModuleClassResolver, packagePartProvider, SupertypeLoopChecker.EMPTY, LookupTracker.DO_NOTHING, module,
         ReflectionTypes(module, notFoundClasses), annotationTypeQualifierResolver,
-        SignatureEnhancement(annotationTypeQualifierResolver, Jsr305State.DISABLED, JavaTypeEnhancement(JavaResolverSettings.Default)),
+        SignatureEnhancement(annotationTypeQualifierResolver, JavaTypeEnhancementState.DISABLED_JSR_305, JavaTypeEnhancement(JavaResolverSettings.Default)),
         JavaClassesTracker.Default, JavaResolverSettings.Default, NewKotlinTypeChecker.Default
     )
 

core/util.runtime/src/org/jetbrains/kotlin/utils/JavaTypeEnhancementState.kt

@@ -30,37 +30,37 @@ enum class ReportLevel(val description: String) {
     val isIgnore: Boolean get() = this == ReportLevel.IGNORE
 }
 
-data class Jsr305State(
+class JavaTypeEnhancementState(
-        val global: ReportLevel,
+    val globalJsr305Level: ReportLevel,
-        val migration: ReportLevel?,
+    val migrationLevelForJsr305: ReportLevel?,
-        val user: Map<String, ReportLevel>,
+    val userDefinedLevelForSpecificJsr305Annotation: Map<String, ReportLevel>,
-        val enableCompatqualCheckerFrameworkAnnotations: Boolean = COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE
+    val enableCompatqualCheckerFrameworkAnnotations: Boolean = COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE
 ) {
     val description: Array<String> by lazy {
         val result = mutableListOf<String>()
-        result.add(global.description)
+        result.add(globalJsr305Level.description)
 
-        migration?.let { result.add("under-migration:${it.description}") }
+        migrationLevelForJsr305?.let { result.add("under-migration:${it.description}") }
 
-        user.forEach {
+        userDefinedLevelForSpecificJsr305Annotation.forEach {
             result.add("@${it.key}:${it.value.description}")
         }
 
         result.toTypedArray()
     }
 
-    val disabled: Boolean get() = this === DISABLED
+    val disabledJsr305: Boolean get() = this === DISABLED_JSR_305
 
     companion object {
         const val COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE = true
 
         @JvmField
-        val DEFAULT: Jsr305State = Jsr305State(ReportLevel.WARN, null, emptyMap())
+        val DEFAULT: JavaTypeEnhancementState = JavaTypeEnhancementState(ReportLevel.WARN, null, emptyMap())
 
         @JvmField
-        val DISABLED: Jsr305State = Jsr305State(ReportLevel.IGNORE, ReportLevel.IGNORE, emptyMap())
+        val DISABLED_JSR_305: JavaTypeEnhancementState = JavaTypeEnhancementState(ReportLevel.IGNORE, ReportLevel.IGNORE, emptyMap())
 
         @JvmField
-        val STRICT: Jsr305State = Jsr305State(ReportLevel.STRICT, ReportLevel.STRICT, emptyMap())
+        val STRICT: JavaTypeEnhancementState = JavaTypeEnhancementState(ReportLevel.STRICT, ReportLevel.STRICT, emptyMap())
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IDELanguageSettingsProvider.kt

@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.platform.TargetPlatformVersion
 import org.jetbrains.kotlin.platform.jvm.JdkPlatform
 import org.jetbrains.kotlin.platform.subplatformsOfType
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 
 object IDELanguageSettingsProvider : LanguageSettingsProvider {
     override fun getLanguageVersionSettings(
@@ -51,7 +51,7 @@ object IDELanguageSettingsProvider : LanguageSettingsProvider {
         when (moduleInfo) {
             is ModuleSourceInfo -> moduleInfo.module.languageVersionSettings
             is LibraryInfo -> project.getLanguageVersionSettings(
-                jsr305State = computeJsr305State(project), isReleaseCoroutines = isReleaseCoroutines
+                javaTypeEnhancementState = computeJavaTypeEnhancementState(project), isReleaseCoroutines = isReleaseCoroutines
             )
             is ScriptModuleInfo -> {
                 getLanguageSettingsForScripts(
@@ -71,8 +71,8 @@ object IDELanguageSettingsProvider : LanguageSettingsProvider {
             else -> project.getLanguageVersionSettings()
         }
 
-    private fun computeJsr305State(project: Project): Jsr305State? {
+    private fun computeJavaTypeEnhancementState(project: Project): JavaTypeEnhancementState? {
-        var result: Jsr305State? = null
+        var result: JavaTypeEnhancementState? = null
         for (module in ModuleManager.getInstance(project).modules) {
             val settings = KotlinFacetSettingsProvider.getInstance(project)?.getSettings(module) ?: continue
             val compilerArguments = settings.mergedCompilerArguments as? K2JVMCompilerArguments ?: continue

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt

@@ -47,7 +47,7 @@ import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.UserDataProperty
-import org.jetbrains.kotlin.utils.Jsr305State
+import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import java.io.File
 
 val KtElement.platform: TargetPlatform
@@ -116,7 +116,7 @@ fun Module.getStableName(): Name {
 @JvmOverloads
 fun Project.getLanguageVersionSettings(
     contextModule: Module? = null,
-    jsr305State: Jsr305State? = null,
+    javaTypeEnhancementState: JavaTypeEnhancementState? = null,
     isReleaseCoroutines: Boolean? = null
 ): LanguageVersionSettings {
     val kotlinFacetSettings = contextModule?.let {
@@ -150,7 +150,7 @@ fun Project.getLanguageVersionSettings(
     }
 
     val extraAnalysisFlags = additionalArguments.configureAnalysisFlags(MessageCollector.NONE).apply {
-        if (jsr305State != null) put(JvmAnalysisFlags.jsr305, jsr305State)
+        if (javaTypeEnhancementState != null) put(JvmAnalysisFlags.jsr305, javaTypeEnhancementState)
         initIDESpecificAnalysisSettings(this@getLanguageVersionSettings)
     }