FE: prefer enhancements for errors over enhancements for warnings

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

@@ -121,17 +121,25 @@ abstract class AbstractAnnotationTypeQualifierResolver<TAnnotation : Any>(
     fun extractNullability(
         annotations: Iterable<TAnnotation>, forceWarning: TAnnotation.() -> Boolean = { false }
     ): NullabilityQualifierWithMigrationStatus? =
-        annotations.firstNotNullOfOrNull { extractNullability(it, forceWarning) }
+        annotations.fold(null as NullabilityQualifierWithMigrationStatus?) { found, annotation ->
+            val extracted = extractNullability(annotation, forceWarning)
+            when {
+                found == null -> extracted
+                extracted == null || extracted == found -> found
+                extracted.isForWarningOnly && !found.isForWarningOnly -> found
+                !extracted.isForWarningOnly && found.isForWarningOnly -> extracted
+                else -> return null // inconsistent
+            }
+        }
 
-    fun extractMutability(annotations: Iterable<TAnnotation>): MutabilityQualifier? {
-        return annotations.fold(null as MutabilityQualifier?) { found, annotation ->
+    fun extractMutability(annotations: Iterable<TAnnotation>): MutabilityQualifier? =
+        annotations.fold(null as MutabilityQualifier?) { found, annotation ->
             when (annotation.fqName) {
                 in READ_ONLY_ANNOTATIONS -> MutabilityQualifier.READ_ONLY
                 in MUTABLE_ANNOTATIONS -> MutabilityQualifier.MUTABLE
-                else -> found
+                else -> return@fold found
             }.also { if (found != null && found != it) return null /* inconsistent */ }
         }
-    }
 
     private fun extractDefaultQualifiers(annotation: TAnnotation): JavaDefaultQualifiers? {
         resolveQualifierBuiltInDefaultAnnotation(annotation)?.let { return it }

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

@@ -135,18 +135,13 @@ abstract class AbstractSignatureParts<TAnnotation : Any> {
         a: NullabilityQualifierWithMigrationStatus?,
         b: NullabilityQualifierWithMigrationStatus?
     ): NullabilityQualifierWithMigrationStatus? {
-        if (a == null) return b
+        if (a == null) return b // null < not null
         if (b == null) return a
-        // TODO: this probably behaves really weirdly when some of those are warnings.
-        if (a.qualifier == NullabilityQualifier.FORCE_FLEXIBILITY) return b
-        if (b.qualifier == NullabilityQualifier.FORCE_FLEXIBILITY) return a
-        if (a.qualifier == NullabilityQualifier.NULLABLE) return b
-        if (b.qualifier == NullabilityQualifier.NULLABLE) return a
-        assert(a.qualifier == b.qualifier && a.qualifier == NullabilityQualifier.NOT_NULL) {
-            "Expected everything is NOT_NULL, but $a and $b are found"
-        }
-
-        return NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL)
+        if (a.isForWarningOnly && !b.isForWarningOnly) return b // warnings < errors
+        if (!a.isForWarningOnly && b.isForWarningOnly) return a
+        if (a.qualifier < b.qualifier) return b // T! < T? < T
+        if (a.qualifier > b.qualifier) return a
+        return b // they are equal
     }
 
     private val TypeParameterMarker.boundsNullability: NullabilityQualifierWithMigrationStatus?

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

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.load.java.typeEnhancement
 
 enum class NullabilityQualifier {
+    FORCE_FLEXIBILITY,
     NULLABLE,
     NOT_NULL,
-    FORCE_FLEXIBILITY
 }
 
 enum class MutabilityQualifier {