azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move more common parts from :compiler:descriptors.jvm

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2020-09-02 15:07:07 +03:00
parent 192e07a07b
commit 1417fcecb8
26 changed files with 235 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt
+9 -38
View File
@@ -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) =
isApplicableConsideringMask(QualifierApplicabilityType.TYPE_USE) || isApplicableConsideringMask(elementType)
private fun isApplicableTo(elementType: AnnotationQualifierApplicabilityType) =
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
"FIELD" -> QualifierApplicabilityType.FIELD
"PARAMETER" -> QualifierApplicabilityType.VALUE_PARAMETER
"TYPE_USE" -> QualifierApplicabilityType.TYPE_USE
"METHOD" -> AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE
"FIELD" -> AnnotationQualifierApplicabilityType.FIELD
"PARAMETER" -> AnnotationQualifierApplicabilityType.VALUE_PARAMETER
"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
-4
View File
@@ -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
+2 -26
View File
@@ -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.JavaClassFinder
import org.jetbrains.kotlin.load.java.JavaClassesTracker
import org.jetbrains.kotlin.load.java.*
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/predefinedEnhancementInfo.kt
-253
View File
@@ -1,253 +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
import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents
import org.jetbrains.kotlin.load.kotlin.signatures
import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType.BOOLEAN
class TypeEnhancementInfo(val map: Map<Int, JavaTypeQualifiers>) {
constructor(vararg pairs: Pair<Int, JavaTypeQualifiers>) : this(mapOf(*pairs))
}
class PredefinedFunctionEnhancementInfo(
val returnTypeInfo: TypeEnhancementInfo? = null,
val parametersInfo: List<TypeEnhancementInfo?> = emptyList()
)
/** Type is always nullable: `T?` */
private val NULLABLE = JavaTypeQualifiers(NullabilityQualifier.NULLABLE, null, isNotNullTypeParameter = false)
/** Nullability depends on substitution, but the type is not platform: `T` */
private val NOT_PLATFORM = JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, isNotNullTypeParameter = false)
/** Type is always non-nullable: `T & Any` */
private val NOT_NULLABLE = JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, isNotNullTypeParameter = true)
@Suppress("LocalVariableName")
val PREDEFINED_FUNCTION_ENHANCEMENT_INFO_BY_SIGNATURE = signatures {
val JLObject = javaLang("Object")
val JFPredicate = javaFunction("Predicate")
val JFFunction = javaFunction("Function")
val JFConsumer = javaFunction("Consumer")
val JFBiFunction = javaFunction("BiFunction")
val JFBiConsumer = javaFunction("BiConsumer")
val JFUnaryOperator = javaFunction("UnaryOperator")
val JUStream = javaUtil("stream/Stream")
val JUOptional = javaUtil("Optional")
enhancement {
forClass(javaUtil("Iterator")) {
function("forEachRemaining") {
parameter(JFConsumer, NOT_PLATFORM, NOT_PLATFORM)
}
}
forClass(javaLang("Iterable")) {
function("spliterator") {
returns(javaUtil("Spliterator"), NOT_PLATFORM, NOT_PLATFORM)
}
}
forClass(javaUtil("Collection")) {
function("removeIf") {
parameter(JFPredicate, NOT_PLATFORM, NOT_PLATFORM)
returns(BOOLEAN)
}
function("stream") {
returns(JUStream, NOT_PLATFORM, NOT_PLATFORM)
}
function("parallelStream") {
returns(JUStream, NOT_PLATFORM, NOT_PLATFORM)
}
}
forClass(javaUtil("List")) {
function("replaceAll") {
parameter(JFUnaryOperator, NOT_PLATFORM, NOT_PLATFORM)
}
}
forClass(javaUtil("Map")) {
function("forEach") {
parameter(JFBiConsumer, NOT_PLATFORM, NOT_PLATFORM, NOT_PLATFORM)
}
function("putIfAbsent") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
returns(JLObject, NULLABLE)
}
function("replace") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
returns(JLObject, NULLABLE)
}
function("replace") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
returns(BOOLEAN)
}
function("replaceAll") {
parameter(JFBiFunction, NOT_PLATFORM, NOT_PLATFORM, NOT_PLATFORM, NOT_PLATFORM)
}
function("compute") {
parameter(JLObject, NOT_PLATFORM)
parameter(JFBiFunction, NOT_PLATFORM, NOT_PLATFORM, NULLABLE, NULLABLE)
returns(JLObject, NULLABLE)
}
// while it is possible to return nullable value from lambda in computeIfAbsent,
// we deliberately make it just NOT_PLATFORM V in order to have the return type V and not V?
function("computeIfAbsent") {
parameter(JLObject, NOT_PLATFORM)
parameter(JFFunction, NOT_PLATFORM, NOT_PLATFORM, NOT_PLATFORM)
returns(JLObject, NOT_PLATFORM)
}
function("computeIfPresent") {
parameter(JLObject, NOT_PLATFORM)
parameter(JFBiFunction, NOT_PLATFORM, NOT_PLATFORM, NOT_NULLABLE, NULLABLE)
returns(JLObject, NULLABLE)
}
function("merge") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_NULLABLE)
parameter(JFBiFunction, NOT_PLATFORM, NOT_NULLABLE, NOT_NULLABLE, NULLABLE)
returns(JLObject, NULLABLE)
}
}
forClass(JUOptional) {
function("empty") {
returns(JUOptional, NOT_PLATFORM, NOT_NULLABLE)
}
function("of") {
parameter(JLObject, NOT_NULLABLE)
returns(JUOptional, NOT_PLATFORM, NOT_NULLABLE)
}
function("ofNullable") {
parameter(JLObject, NULLABLE)
returns(JUOptional, NOT_PLATFORM, NOT_NULLABLE)
}
function("get") {
returns(JLObject, NOT_NULLABLE)
}
function("ifPresent") {
parameter(JFConsumer, NOT_PLATFORM, NOT_NULLABLE)
}
}
forClass(javaLang("ref/Reference")) {
function("get") {
returns(JLObject, NULLABLE)
}
}
forClass(JFPredicate) {
function("test") {
parameter(JLObject, NOT_PLATFORM)
returns(BOOLEAN)
}
}
forClass(javaFunction("BiPredicate")) {
function("test") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
returns(BOOLEAN)
}
}
forClass(JFConsumer) {
function("accept") {
parameter(JLObject, NOT_PLATFORM)
}
}
forClass(JFBiConsumer) {
function("accept") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
}
}
forClass(JFFunction) {
function("apply") {
parameter(JLObject, NOT_PLATFORM)
returns(JLObject, NOT_PLATFORM)
}
}
forClass(JFBiFunction) {
function("apply") {
parameter(JLObject, NOT_PLATFORM)
parameter(JLObject, NOT_PLATFORM)
returns(JLObject, NOT_PLATFORM)
}
}
forClass(javaFunction("Supplier")) {
function("get") {
returns(JLObject, NOT_PLATFORM)
}
}
}
}
private inline fun enhancement(block: SignatureEnhancementBuilder.() -> Unit): Map<String, PredefinedFunctionEnhancementInfo> =
SignatureEnhancementBuilder().apply(block).build()
private class SignatureEnhancementBuilder {
private val signatures = mutableMapOf<String, PredefinedFunctionEnhancementInfo>()
inline fun forClass(internalName: String, block: ClassEnhancementBuilder.() -> Unit) =
ClassEnhancementBuilder(internalName).block()
inner class ClassEnhancementBuilder(val className: String) {
fun function(name: String, block: FunctionEnhancementBuilder.() -> Unit) {
signatures += FunctionEnhancementBuilder(name).apply(block).build()
}
inner class FunctionEnhancementBuilder(val functionName: String) {
private val parameters = mutableListOf<Pair<String, TypeEnhancementInfo?>>()
private var returnType: Pair<String, TypeEnhancementInfo?> = "V" to null
fun parameter(type: String, vararg pairs: Pair<Int, JavaTypeQualifiers>) {
parameters += type to
if (pairs.isEmpty()) null else TypeEnhancementInfo(*pairs)
}
fun parameter(type: String, vararg qualifiers: JavaTypeQualifiers) {
parameters += type to
if (qualifiers.isEmpty()) null else TypeEnhancementInfo(
qualifiers.withIndex().associateBy(
{ it.index },
{ it.value })
)
}
fun returns(type: String, vararg pairs: Pair<Int, JavaTypeQualifiers>) {
returnType = type to TypeEnhancementInfo(*pairs)
}
fun returns(type: String, vararg qualifiers: JavaTypeQualifiers) {
returnType = type to TypeEnhancementInfo(qualifiers.withIndex().associateBy({ it.index }, { it.value }))
}
fun returns(type: JvmPrimitiveType) {
returnType = type.desc to null
}
fun build() = with(SignatureBuildingComponents) {
signature(className, jvmDescriptor(functionName, parameters.map { it.first }, returnType.first)) to
PredefinedFunctionEnhancementInfo(returnType.second, parameters.map { it.second })
}
}
}
fun build(): Map<String, PredefinedFunctionEnhancementInfo> = signatures
}
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt
+7 -44
View File
@@ -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
-2
View File
@@ -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
-39
View File
@@ -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
+2 -13
View File
@@ -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/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/JvmPackagePartSource.kt
-76
View File
@@ -1,76 +0,0 @@
/*
* Copyright 2010-2015 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.kotlin
import org.jetbrains.kotlin.descriptors.SourceFile
import org.jetbrains.kotlin.metadata.ProtoBuf
import org.jetbrains.kotlin.metadata.deserialization.NameResolver
import org.jetbrains.kotlin.metadata.deserialization.getExtensionOrNull
import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.jvm.JvmClassName
import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
class JvmPackagePartSource(
val className: JvmClassName,
val facadeClassName: JvmClassName?,
packageProto: ProtoBuf.Package,
nameResolver: NameResolver,
override val incompatibility: IncompatibleVersionErrorData<JvmMetadataVersion>? = null,
override val isPreReleaseInvisible: Boolean = false,
override val isInvisibleIrDependency: Boolean = false,
val knownJvmBinaryClass: KotlinJvmBinaryClass? = null
) : DeserializedContainerSource {
constructor(
kotlinClass: KotlinJvmBinaryClass,
packageProto: ProtoBuf.Package,
nameResolver: NameResolver,
incompatibility: IncompatibleVersionErrorData<JvmMetadataVersion>? = null,
isPreReleaseInvisible: Boolean = false,
isInvisibleIrDependency: Boolean = false
) : this(
JvmClassName.byClassId(kotlinClass.classId),
kotlinClass.classHeader.multifileClassName?.let {
if (it.isNotEmpty()) JvmClassName.byInternalName(it) else null
},
packageProto,
nameResolver,
incompatibility,
isPreReleaseInvisible,
isInvisibleIrDependency,
kotlinClass
)
val moduleName =
packageProto.getExtensionOrNull(JvmProtoBuf.packageModuleName)?.let(nameResolver::getString)
?: JvmProtoBufUtil.DEFAULT_MODULE_NAME
override val presentableString: String
get() = "Class '${classId.asSingleFqName().asString()}'"
val simpleName: Name get() = Name.identifier(className.internalName.substringAfterLast('/'))
val classId: ClassId get() = ClassId(className.packageFqName, simpleName)
override fun toString() = "${this::class.java.simpleName}: $className"
override fun getContainingFile(): SourceFile = SourceFile.NO_SOURCE_FILE
}
core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/PackagePartProvider.kt
-32
View File
@@ -1,32 +0,0 @@
/*
* 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.kotlin
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.serialization.deserialization.ClassData
interface PackagePartProvider {
/**
* @return JVM internal names of package parts existing in the package with the given FQ name.
*
* For example, if a file named foo.kt in package org.test is compiled to a library, PackagePartProvider for such library
* must return the list `["org/test/FooKt"]` for the query `"org.test"`
* (in case the file is not annotated with @JvmName, @JvmPackageName or @JvmMultifileClass).
*/
fun findPackageParts(packageFqName: String): List<String>
fun getAnnotationsOnBinaryModule(moduleName: String): List<ClassId>
fun getAllOptionalAnnotationClasses(): List<ClassData>
object Empty : PackagePartProvider {
override fun findPackageParts(packageFqName: String): List<String> = emptyList()
override fun getAnnotationsOnBinaryModule(moduleName: String): List<ClassId> = emptyList()
override fun getAllOptionalAnnotationClasses(): List<ClassData> = emptyList()
}
}