Move more common parts from :compiler:descriptors.jvm

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.java.deserialization
 
 import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.SpecialJvmAnnotations
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
@@ -295,7 +296,7 @@ class KotlinDeserializedJvmSymbolsProvider(
     internal fun loadAnnotationIfNotSpecial(
         annotationClassId: ClassId, result: MutableList<FirAnnotationCall>,
     ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
-        if (annotationClassId in AbstractBinaryClassAnnotationAndConstantLoader.SPECIAL_ANNOTATIONS) return null
+        if (annotationClassId in SpecialJvmAnnotations.SPECIAL_ANNOTATIONS) return null
         return loadAnnotation(annotationClassId, result)
     }
 

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.java.toFirJavaTypeRef
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
-import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
+import org.jetbrains.kotlin.load.java.AnnotationQualifierApplicabilityType
 import org.jetbrains.kotlin.load.java.MUTABLE_ANNOTATIONS
 import org.jetbrains.kotlin.load.java.READ_ONLY_ANNOTATIONS
 import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
@@ -37,7 +37,7 @@ internal class EnhancementSignatureParts(
     private val fromOverridden: Collection<FirTypeRef>,
     private val isCovariant: Boolean,
     private val context: FirJavaEnhancementContext,
-    private val containerApplicabilityType: AnnotationTypeQualifierResolver.QualifierApplicabilityType
+    private val containerApplicabilityType: AnnotationQualifierApplicabilityType
 ) {
     private val isForVarargParameter get() = typeContainer.safeAs<FirValueParameter>()?.isVararg == true
 
@@ -103,7 +103,7 @@ internal class EnhancementSignatureParts(
                 TypeAndDefaultQualifiers(
                     type,
                     c.defaultTypeQualifiers
-                        ?.get(AnnotationTypeQualifierResolver.QualifierApplicabilityType.TYPE_USE)
+                        ?.get(AnnotationQualifierApplicabilityType.TYPE_USE)
                 )
             )
 

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.fir.resolve.toSymbol
 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.load.java.lazy.NullabilityQualifierWithApplicability
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.utils.Jsr305State
 import org.jetbrains.kotlin.utils.ReportLevel
@@ -26,14 +25,14 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
         private val applicability: Int
     ) {
         operator fun component1() = typeQualifier
-        operator fun component2() = AnnotationTypeQualifierResolver.QualifierApplicabilityType.values().filter(this::isApplicableTo)
+        operator fun component2() = AnnotationQualifierApplicabilityType.values().filter(this::isApplicableTo)
 
-        private fun isApplicableTo(elementType: AnnotationTypeQualifierResolver.QualifierApplicabilityType) =
+        private fun isApplicableTo(elementType: AnnotationQualifierApplicabilityType) =
-            isApplicableConsideringMask(AnnotationTypeQualifierResolver.QualifierApplicabilityType.TYPE_USE) || isApplicableConsideringMask(
+            isApplicableConsideringMask(AnnotationQualifierApplicabilityType.TYPE_USE) || isApplicableConsideringMask(
                 elementType
             )
 
-        private fun isApplicableConsideringMask(elementType: AnnotationTypeQualifierResolver.QualifierApplicabilityType) =
+        private fun isApplicableConsideringMask(elementType: AnnotationQualifierApplicabilityType) =
             (applicability and (1 shl elementType.ordinal)) != 0
     }
 
@@ -132,15 +131,15 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
         }
     }
 
-    private fun FirExpression.mapConstantToQualifierApplicabilityTypes(): List<AnnotationTypeQualifierResolver.QualifierApplicabilityType> =
+    private fun FirExpression.mapConstantToQualifierApplicabilityTypes(): List<AnnotationQualifierApplicabilityType> =
         when (this) {
             is FirArrayOfCall -> arguments.flatMap { it.mapConstantToQualifierApplicabilityTypes() }
             else -> listOfNotNull(
                 when (toResolvedCallableSymbol()?.callableId?.callableName?.asString()) {
-                    "METHOD" -> AnnotationTypeQualifierResolver.QualifierApplicabilityType.METHOD_RETURN_TYPE
+                    "METHOD" -> AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE
-                    "FIELD" -> AnnotationTypeQualifierResolver.QualifierApplicabilityType.FIELD
+                    "FIELD" -> AnnotationQualifierApplicabilityType.FIELD
-                    "PARAMETER" -> AnnotationTypeQualifierResolver.QualifierApplicabilityType.VALUE_PARAMETER
+                    "PARAMETER" -> AnnotationQualifierApplicabilityType.VALUE_PARAMETER
-                    "TYPE_USE" -> AnnotationTypeQualifierResolver.QualifierApplicabilityType.TYPE_USE
+                    "TYPE_USE" -> AnnotationQualifierApplicabilityType.TYPE_USE
                     else -> null
                 }
             )

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

@@ -7,10 +7,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.AnnotationTypeQualifierResolver
+import org.jetbrains.kotlin.load.java.*
-import org.jetbrains.kotlin.load.java.lazy.JavaTypeQualifiersByElementType
-import org.jetbrains.kotlin.load.java.lazy.NullabilityQualifierWithApplicability
-import org.jetbrains.kotlin.load.java.lazy.QualifierByApplicabilityType
 import org.jetbrains.kotlin.utils.Jsr305State
 
 class FirJavaEnhancementContext private constructor(
@@ -71,7 +68,7 @@ fun FirJavaEnhancementContext.computeNewDefaultTypeQualifiers(
 
     val nullabilityQualifiersByType =
         defaultTypeQualifiers?.nullabilityQualifiers?.let(::QualifierByApplicabilityType)
-            ?: QualifierByApplicabilityType(AnnotationTypeQualifierResolver.QualifierApplicabilityType::class.java)
+            ?: QualifierByApplicabilityType(AnnotationQualifierApplicabilityType::class.java)
 
     var wasUpdate = false
     for ((nullability, applicableTo) in nullabilityQualifiersWithApplicability) {
@@ -94,4 +91,4 @@ fun FirJavaEnhancementContext.copyWithNewDefaultTypeQualifiers(
         else -> FirJavaEnhancementContext(session) {
             computeNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, additionalAnnotations)
         }
-    }
+    }

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

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
-import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
+import org.jetbrains.kotlin.load.java.AnnotationQualifierApplicabilityType
 import org.jetbrains.kotlin.load.java.descriptors.NullDefaultValue
 import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue
 import org.jetbrains.kotlin.load.java.typeEnhancement.*
@@ -317,8 +317,8 @@ class FirSignatureEnhancement(
             typeContainer = owner, isCovariant = true,
             containerContext = memberContext,
             containerApplicabilityType =
-            if (owner is FirJavaField) AnnotationTypeQualifierResolver.QualifierApplicabilityType.FIELD
+            if (owner is FirJavaField) AnnotationQualifierApplicabilityType.FIELD
-            else AnnotationTypeQualifierResolver.QualifierApplicabilityType.METHOD_RETURN_TYPE,
+            else AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE,
             typeInSignature = TypeInSignature.Return
         ).enhance(session, jsr305State, predefinedEnhancementInfo?.returnTypeInfo)
         return signatureParts.type
@@ -364,7 +364,7 @@ class FirSignatureEnhancement(
         parameterContainer?.let {
             methodContext.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, it.annotations)
         } ?: methodContext,
-        AnnotationTypeQualifierResolver.QualifierApplicabilityType.VALUE_PARAMETER,
+        AnnotationQualifierApplicabilityType.VALUE_PARAMETER,
         typeInSignature
     )
 
@@ -374,7 +374,7 @@ class FirSignatureEnhancement(
         typeContainer: FirAnnotationContainer?,
         isCovariant: Boolean,
         containerContext: FirJavaEnhancementContext,
-        containerApplicabilityType: AnnotationTypeQualifierResolver.QualifierApplicabilityType,
+        containerApplicabilityType: AnnotationQualifierApplicabilityType,
         typeInSignature: TypeInSignature
     ): EnhancementSignatureParts {
         val typeRef = typeInSignature.getTypeRef(this)

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

@@ -0,0 +1,10 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java
+
+enum class AnnotationQualifierApplicabilityType {
+    METHOD_RETURN_TYPE, VALUE_PARAMETER, FIELD, TYPE_USE
+}

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

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+package 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.FqName
+
+val TYPE_QUALIFIER_NICKNAME_FQNAME = FqName("javax.annotation.meta.TypeQualifierNickname")
+val TYPE_QUALIFIER_FQNAME = FqName("javax.annotation.meta.TypeQualifier")
+val TYPE_QUALIFIER_DEFAULT_FQNAME = FqName("javax.annotation.meta.TypeQualifierDefault")
+
+val MIGRATION_ANNOTATION_FQNAME = FqName("kotlin.annotations.jvm.UnderMigration")
+
+val BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATIONS = mapOf(
+    FqName("javax.annotation.ParametersAreNullableByDefault") to
+            NullabilityQualifierWithApplicability(
+                NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE),
+                listOf(AnnotationQualifierApplicabilityType.VALUE_PARAMETER)
+            ),
+    FqName("javax.annotation.ParametersAreNonnullByDefault") to
+            NullabilityQualifierWithApplicability(
+                NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL),
+                listOf(AnnotationQualifierApplicabilityType.VALUE_PARAMETER)
+            )
+)
+
+val BUILT_IN_TYPE_QUALIFIER_FQ_NAMES = setOf(JAVAX_NONNULL_ANNOTATION, JAVAX_CHECKFORNULL_ANNOTATION)

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

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java
+
+import org.jetbrains.kotlin.load.java.typeEnhancement.JavaTypeQualifiers
+import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus
+import java.util.*
+
+typealias QualifierByApplicabilityType = EnumMap<AnnotationQualifierApplicabilityType, NullabilityQualifierWithMigrationStatus?>
+
+class JavaTypeQualifiersByElementType(val nullabilityQualifiers: QualifierByApplicabilityType) {
+    operator fun get(applicabilityType: AnnotationQualifierApplicabilityType?): JavaTypeQualifiers? {
+        val nullabilityQualifierWithMigrationStatus = nullabilityQualifiers[applicabilityType] ?: return null
+
+        return JavaTypeQualifiers(
+            nullabilityQualifierWithMigrationStatus.qualifier, null,
+            isNotNullTypeParameter = false,
+            isNullabilityQualifierForWarning = nullabilityQualifierWithMigrationStatus.isForWarningOnly
+        )
+    }
+}

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

@@ -0,0 +1,13 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java
+
+import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus
+
+data class NullabilityQualifierWithApplicability(
+    val nullabilityQualifier: NullabilityQualifierWithMigrationStatus,
+    val qualifierApplicabilityTypes: Collection<AnnotationQualifierApplicabilityType>
+)

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

@@ -0,0 +1,12 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java.descriptors
+
+sealed class AnnotationDefaultValue
+
+class StringDefaultValue(val value: String) : AnnotationDefaultValue()
+
+object NullDefaultValue : AnnotationDefaultValue()

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

@@ -0,0 +1,11 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java.typeEnhancement
+
+data class NullabilityQualifierWithMigrationStatus(
+    val qualifier: NullabilityQualifier,
+    val isForWarningOnly: Boolean = false
+)

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

@@ -10,3 +10,5 @@ enum class TypeComponentPosition {
     FLEXIBLE_UPPER,
     INFLEXIBLE
 }
+
+fun TypeComponentPosition.shouldEnhance(): Boolean = this != TypeComponentPosition.INFLEXIBLE

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

@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java.typeEnhancement
+
+fun createJavaTypeQualifiers(
+    nullability: NullabilityQualifier?,
+    mutability: MutabilityQualifier?,
+    forWarning: Boolean,
+    isAnyNonNullTypeParameter: Boolean
+): JavaTypeQualifiers {
+    if (!isAnyNonNullTypeParameter || nullability != NullabilityQualifier.NOT_NULL) {
+        return JavaTypeQualifiers(nullability, mutability, false, forWarning)
+    }
+    return JavaTypeQualifiers(nullability, mutability, true, forWarning)
+}
+
+fun <T : Any> Set<T>.select(low: T, high: T, own: T?, isCovariant: Boolean): T? {
+    if (isCovariant) {
+        val supertypeQualifier = if (low in this) low else if (high in this) high else null
+        return if (supertypeQualifier == low && own == high) null else own ?: supertypeQualifier
+    }
+
+    // isInvariant
+    val effectiveSet = own?.let { (this + own).toSet() } ?: this
+    // if this set contains exactly one element, it is the qualifier everybody agrees upon,
+    // otherwise (no qualifiers, or multiple qualifiers), there's no single such qualifier
+    // and all qualifiers are discarded
+    return effectiveSet.singleOrNull()
+}
+
+fun Set<NullabilityQualifier>.select(own: NullabilityQualifier?, isCovariant: Boolean) =
+    if (own == NullabilityQualifier.FORCE_FLEXIBILITY)
+        NullabilityQualifier.FORCE_FLEXIBILITY
+    else
+        select(NullabilityQualifier.NOT_NULL, NullabilityQualifier.NULLABLE, own, isCovariant)

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

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin.load.java.typeEnhancement
+
+enum class NullabilityQualifier {
+    NULLABLE,
+    NOT_NULL,
+    FORCE_FLEXIBILITY
+}
+
+enum class MutabilityQualifier {
+    READ_ONLY,
+    MUTABLE
+}
+
+class JavaTypeQualifiers(
+    val nullability: NullabilityQualifier?,
+    val mutability: MutabilityQualifier?,
+    val isNotNullTypeParameter: Boolean,
+    val isNullabilityQualifierForWarning: Boolean = false
+) {
+    companion object {
+        val NONE = JavaTypeQualifiers(null, null, false)
+    }
+}

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

@@ -19,10 +19,6 @@ package org.jetbrains.kotlin.load.java
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.load.java.lazy.NullabilityQualifierWithApplicability
-import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifier
-import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.constants.ArrayValue
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.constants.EnumValue
@@ -34,41 +30,18 @@ import org.jetbrains.kotlin.utils.Jsr305State
 import org.jetbrains.kotlin.utils.ReportLevel
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
-val TYPE_QUALIFIER_NICKNAME_FQNAME = FqName("javax.annotation.meta.TypeQualifierNickname")
-val TYPE_QUALIFIER_FQNAME = FqName("javax.annotation.meta.TypeQualifier")
-val TYPE_QUALIFIER_DEFAULT_FQNAME = FqName("javax.annotation.meta.TypeQualifierDefault")
-
-val MIGRATION_ANNOTATION_FQNAME = FqName("kotlin.annotations.jvm.UnderMigration")
-
-val BUILT_IN_TYPE_QUALIFIER_DEFAULT_ANNOTATIONS = mapOf(
-    FqName("javax.annotation.ParametersAreNullableByDefault") to
-            NullabilityQualifierWithApplicability(
-                NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE),
-                listOf(AnnotationTypeQualifierResolver.QualifierApplicabilityType.VALUE_PARAMETER)
-            ),
-    FqName("javax.annotation.ParametersAreNonnullByDefault") to
-            NullabilityQualifierWithApplicability(
-                NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL),
-                listOf(AnnotationTypeQualifierResolver.QualifierApplicabilityType.VALUE_PARAMETER)
-            )
-)
-
 class AnnotationTypeQualifierResolver(storageManager: StorageManager, private val jsr305State: Jsr305State) {
-    enum class QualifierApplicabilityType {
-        METHOD_RETURN_TYPE, VALUE_PARAMETER, FIELD, TYPE_USE
-    }
-
     class TypeQualifierWithApplicability(
         private val typeQualifier: AnnotationDescriptor,
         private val applicability: Int
     ) {
         operator fun component1() = typeQualifier
-        operator fun component2() = QualifierApplicabilityType.values().filter(this::isApplicableTo)
+        operator fun component2() = AnnotationQualifierApplicabilityType.values().filter(this::isApplicableTo)
 
-        private fun isApplicableTo(elementType: QualifierApplicabilityType) =
+        private fun isApplicableTo(elementType: AnnotationQualifierApplicabilityType) =
-            isApplicableConsideringMask(QualifierApplicabilityType.TYPE_USE) || isApplicableConsideringMask(elementType)
+            isApplicableConsideringMask(AnnotationQualifierApplicabilityType.TYPE_USE) || isApplicableConsideringMask(elementType)
 
-        private fun isApplicableConsideringMask(elementType: QualifierApplicabilityType) =
+        private fun isApplicableConsideringMask(elementType: AnnotationQualifierApplicabilityType) =
             (applicability and (1 shl elementType.ordinal)) != 0
     }
 
@@ -160,15 +133,15 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
         }
     }
 
-    private fun ConstantValue<*>.mapConstantToQualifierApplicabilityTypes(): List<QualifierApplicabilityType> =
+    private fun ConstantValue<*>.mapConstantToQualifierApplicabilityTypes(): List<AnnotationQualifierApplicabilityType> =
         when (this) {
             is ArrayValue -> value.flatMap { it.mapConstantToQualifierApplicabilityTypes() }
             is EnumValue -> listOfNotNull(
                 when (enumEntryName.identifier) {
-                    "METHOD" -> QualifierApplicabilityType.METHOD_RETURN_TYPE
+                    "METHOD" -> AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE
-                    "FIELD" -> QualifierApplicabilityType.FIELD
+                    "FIELD" -> AnnotationQualifierApplicabilityType.FIELD
-                    "PARAMETER" -> QualifierApplicabilityType.VALUE_PARAMETER
+                    "PARAMETER" -> AnnotationQualifierApplicabilityType.VALUE_PARAMETER
-                    "TYPE_USE" -> QualifierApplicabilityType.TYPE_USE
+                    "TYPE_USE" -> AnnotationQualifierApplicabilityType.TYPE_USE
                     else -> null
                 }
             )
@@ -178,7 +151,5 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va
     val disabled: Boolean = jsr305State.disabled
 }
 
-val BUILT_IN_TYPE_QUALIFIER_FQ_NAMES = setOf(JAVAX_NONNULL_ANNOTATION, JAVAX_CHECKFORNULL_ANNOTATION)
-
 private val ClassDescriptor.isAnnotatedWithTypeQualifier: Boolean
     get() = fqNameSafe in BUILT_IN_TYPE_QUALIFIER_FQ_NAMES || annotations.hasAnnotation(TYPE_QUALIFIER_FQNAME)

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

@@ -82,10 +82,6 @@ fun ValueParameterDescriptor.getParameterNameAnnotation(): AnnotationDescriptor?
     return annotation
 }
 
-sealed class AnnotationDefaultValue
-class StringDefaultValue(val value: String) : AnnotationDefaultValue()
-object NullDefaultValue : AnnotationDefaultValue()
-
 fun ValueParameterDescriptor.getDefaultValueFromAnnotation(): AnnotationDefaultValue? {
     annotations.findAnnotation(JvmAnnotationNames.DEFAULT_VALUE_FQ_NAME)
         ?.firstArgument()

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

@@ -24,17 +24,13 @@ import org.jetbrains.kotlin.descriptors.SupertypeLoopChecker
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver
+import org.jetbrains.kotlin.load.java.*
-import org.jetbrains.kotlin.load.java.JavaClassFinder
-import org.jetbrains.kotlin.load.java.JavaClassesTracker
 import org.jetbrains.kotlin.load.java.components.JavaPropertyInitializerEvaluator
 import org.jetbrains.kotlin.load.java.components.JavaResolverCache
 import org.jetbrains.kotlin.load.java.components.SignaturePropagator
 import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeResolver
 import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory
 import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner
-import org.jetbrains.kotlin.load.java.typeEnhancement.JavaTypeQualifiers
-import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus
 import org.jetbrains.kotlin.load.java.typeEnhancement.SignatureEnhancement
 import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver
 import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
@@ -43,7 +39,6 @@ import org.jetbrains.kotlin.resolve.sam.SamConversionResolver
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker
-import java.util.*
 
 class JavaResolverComponents(
     val storageManager: StorageManager,
@@ -104,20 +99,6 @@ interface JavaResolverSettings {
     }
 }
 
-typealias QualifierByApplicabilityType = EnumMap<AnnotationTypeQualifierResolver.QualifierApplicabilityType, NullabilityQualifierWithMigrationStatus?>
-
-class JavaTypeQualifiersByElementType(val nullabilityQualifiers: QualifierByApplicabilityType) {
-    operator fun get(applicabilityType: AnnotationTypeQualifierResolver.QualifierApplicabilityType?): JavaTypeQualifiers? {
-        val nullabilityQualifierWithMigrationStatus = nullabilityQualifiers[applicabilityType] ?: return null
-
-        return JavaTypeQualifiers(
-            nullabilityQualifierWithMigrationStatus.qualifier, null,
-            isNotNullTypeParameter = false,
-            isNullabilityQualifierForWarning = nullabilityQualifierWithMigrationStatus.isForWarningOnly
-        )
-    }
-}
-
 class LazyJavaResolverContext internal constructor(
     val components: JavaResolverComponents,
     val typeParameterResolver: TypeParameterResolver,
@@ -155,7 +136,7 @@ fun LazyJavaResolverContext.computeNewDefaultTypeQualifiers(
 
     val nullabilityQualifiersByType =
         defaultTypeQualifiers?.nullabilityQualifiers?.let(::QualifierByApplicabilityType)
-            ?: QualifierByApplicabilityType(AnnotationTypeQualifierResolver.QualifierApplicabilityType::class.java)
+            ?: QualifierByApplicabilityType(AnnotationQualifierApplicabilityType::class.java)
 
     var wasUpdate = false
     for ((nullability, applicableTo) in nullabilityQualifiersWithApplicability) {
@@ -195,11 +176,6 @@ private fun LazyJavaResolverContext.extractDefaultNullabilityQualifier(
     return NullabilityQualifierWithApplicability(nullabilityQualifier, applicability)
 }
 
-data class NullabilityQualifierWithApplicability(
-    val nullabilityQualifier: NullabilityQualifierWithMigrationStatus,
-    val qualifierApplicabilityTypes: Collection<AnnotationTypeQualifierResolver.QualifierApplicabilityType>
-)
-
 fun LazyJavaResolverContext.replaceComponents(
     components: JavaResolverComponents
 ) = LazyJavaResolverContext(components, typeParameterResolver, delegateForDefaultTypeQualifiers)

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

@@ -43,11 +43,6 @@ import org.jetbrains.kotlin.utils.Jsr305State
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
-data class NullabilityQualifierWithMigrationStatus(
-    val qualifier: NullabilityQualifier,
-    val isForWarningOnly: Boolean = false
-)
-
 class SignatureEnhancement(
     private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver,
     private val jsr305State: Jsr305State,
@@ -180,9 +175,9 @@ class SignatureEnhancement(
                 containerContext = memberContext,
                 containerApplicabilityType =
                 if (this.safeAs<PropertyDescriptor>()?.isJavaField == true)
-                    AnnotationTypeQualifierResolver.QualifierApplicabilityType.FIELD
+                    AnnotationQualifierApplicabilityType.FIELD
                 else
-                    AnnotationTypeQualifierResolver.QualifierApplicabilityType.METHOD_RETURN_TYPE
+                    AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE
             ) { it.returnType!! }.enhance(predefinedEnhancementInfo?.returnTypeInfo)
 
         val containsFunctionN = receiverTypeEnhancement?.containsFunctionN == true || returnTypeEnhancement.containsFunctionN ||
@@ -225,7 +220,7 @@ class SignatureEnhancement(
         private val fromOverridden: Collection<KotlinType>,
         private val isCovariant: Boolean,
         private val containerContext: LazyJavaResolverContext,
-        private val containerApplicabilityType: AnnotationTypeQualifierResolver.QualifierApplicabilityType
+        private val containerApplicabilityType: AnnotationQualifierApplicabilityType
     ) {
 
         private val isForVarargParameter get() = typeContainer.safeAs<ValueParameterDescriptor>()?.varargElementType != null
@@ -300,7 +295,7 @@ class SignatureEnhancement(
                 composedAnnotation.extractNullability()
                     ?: defaultTypeQualifier?.nullability?.let {
                         NullabilityQualifierWithMigrationStatus(
-                            defaultTypeQualifier.nullability,
+                            defaultTypeQualifier.nullability!!,
                             defaultTypeQualifier.isNullabilityQualifierForWarning
                         )
                     }
@@ -361,7 +356,7 @@ class SignatureEnhancement(
                     TypeAndDefaultQualifiers(
                         type,
                         c.defaultTypeQualifiers
-                            ?.get(AnnotationTypeQualifierResolver.QualifierApplicabilityType.TYPE_USE)
+                            ?.get(AnnotationQualifierApplicabilityType.TYPE_USE)
                     )
                 )
 
@@ -448,7 +443,7 @@ class SignatureEnhancement(
     ) = parts(
         parameterDescriptor, false,
         parameterDescriptor?.let { methodContext.copyWithNewDefaultTypeQualifiers(it.annotations) } ?: methodContext,
-        AnnotationTypeQualifierResolver.QualifierApplicabilityType.VALUE_PARAMETER,
+        AnnotationQualifierApplicabilityType.VALUE_PARAMETER,
         collector
     )
 
@@ -456,7 +451,7 @@ class SignatureEnhancement(
         typeContainer: Annotated?,
         isCovariant: Boolean,
         containerContext: LazyJavaResolverContext,
-        containerApplicabilityType: AnnotationTypeQualifierResolver.QualifierApplicabilityType,
+        containerApplicabilityType: AnnotationQualifierApplicabilityType,
         collector: (CallableMemberDescriptor) -> KotlinType
     ): SignatureParts {
         return SignatureParts(
@@ -473,38 +468,6 @@ class SignatureEnhancement(
     }
 }
 
-fun createJavaTypeQualifiers(
-    nullability: NullabilityQualifier?,
-    mutability: MutabilityQualifier?,
-    forWarning: Boolean,
-    isAnyNonNullTypeParameter: Boolean
-): JavaTypeQualifiers {
-    if (!isAnyNonNullTypeParameter || nullability != NullabilityQualifier.NOT_NULL) {
-        return JavaTypeQualifiers(nullability, mutability, false, forWarning)
-    }
-    return JavaTypeQualifiers(nullability, mutability, true, forWarning)
-}
-
-fun <T : Any> Set<T>.select(low: T, high: T, own: T?, isCovariant: Boolean): T? {
-    if (isCovariant) {
-        val supertypeQualifier = if (low in this) low else if (high in this) high else null
-        return if (supertypeQualifier == low && own == high) null else own ?: supertypeQualifier
-    }
-
-    // isInvariant
-    val effectiveSet = own?.let { (this + own).toSet() } ?: this
-    // if this set contains exactly one element, it is the qualifier everybody agrees upon,
-    // otherwise (no qualifiers, or multiple qualifiers), there's no single such qualifier
-    // and all qualifiers are discarded
-    return effectiveSet.singleOrNull()
-}
-
-fun Set<NullabilityQualifier>.select(own: NullabilityQualifier?, isCovariant: Boolean) =
-    if (own == NullabilityQualifier.FORCE_FLEXIBILITY)
-        NullabilityQualifier.FORCE_FLEXIBILITY
-    else
-        select(NullabilityQualifier.NOT_NULL, NullabilityQualifier.NULLABLE, own, isCovariant)
-
 private data class TypeAndDefaultQualifiers(
     val type: KotlinType,
     val defaultQualifiers: JavaTypeQualifiers?

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

@@ -159,8 +159,6 @@ private fun List<Annotations>.compositeAnnotationsOrSingle() = when (size) {
     else -> CompositeAnnotations(this.toList())
 }
 
-fun TypeComponentPosition.shouldEnhance() = this != TypeComponentPosition.INFLEXIBLE
-
 private data class EnhancementResult<out T>(val result: T, val enhancementAnnotations: Annotations?)
 
 private fun <T> T.noChange() = EnhancementResult(this, null)

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

@@ -1,39 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.load.java.typeEnhancement
-
-enum class NullabilityQualifier {
-    NULLABLE,
-    NOT_NULL,
-    FORCE_FLEXIBILITY
-}
-
-enum class MutabilityQualifier {
-    READ_ONLY,
-    MUTABLE
-}
-
-class JavaTypeQualifiers(
-    val nullability: NullabilityQualifier?,
-    val mutability: MutabilityQualifier?,
-    val isNotNullTypeParameter: Boolean,
-    val isNullabilityQualifierForWarning: Boolean = false
-) {
-    companion object {
-        val NONE = JavaTypeQualifiers(null, null, false)
-    }
-}

core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt

@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.load.kotlin
 
+import org.jetbrains.kotlin.SpecialJvmAnnotations
 import org.jetbrains.kotlin.builtins.UnsignedTypes
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.*
 import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
@@ -62,7 +62,7 @@ abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any>(
         source: SourceElement,
         result: MutableList<A>
     ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
-        if (annotationClassId in SPECIAL_ANNOTATIONS) return null
+        if (annotationClassId in SpecialJvmAnnotations.SPECIAL_ANNOTATIONS) return null
 
         return loadAnnotation(annotationClassId, source, result)
     }
@@ -409,15 +409,4 @@ abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C : Any>(
         val memberAnnotations: Map<MemberSignature, List<A>>,
         val propertyConstants: Map<MemberSignature, C>
     )
-
-    companion object {
-        val SPECIAL_ANNOTATIONS = listOf(
-            JvmAnnotationNames.METADATA_FQ_NAME,
-            JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION,
-            JvmAnnotationNames.JETBRAINS_NULLABLE_ANNOTATION,
-            FqName("java.lang.annotation.Target"),
-            FqName("java.lang.annotation.Retention"),
-            FqName("java.lang.annotation.Documented")
-        ).map(ClassId::topLevel).toSet()
-    }
 }

core/metadata.jvm/src/org/jetbrains/kotlin/SpecialJvmAnnotations.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+package org.jetbrains.kotlin
+
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+
+object SpecialJvmAnnotations {
+    val SPECIAL_ANNOTATIONS: Set<ClassId> = listOf(
+        JvmAnnotationNames.METADATA_FQ_NAME,
+        JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION,
+        JvmAnnotationNames.JETBRAINS_NULLABLE_ANNOTATION,
+        FqName("java.lang.annotation.Target"),
+        FqName("java.lang.annotation.Retention"),
+        FqName("java.lang.annotation.Documented")
+    ).mapTo(mutableSetOf(), ClassId::topLevel)
+}

core/metadata.jvm/src/org/jetbrains/kotlin/load/kotlin/JvmPackagePartSource.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * 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.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
 
 package org.jetbrains.kotlin.load.kotlin

core/metadata/src/org/jetbrains/kotlin/serialization/deserialization/NameResolverUtil.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-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.
  */