From 476513fe96cc640fe9c11991dfbabd8728fef592 Mon Sep 17 00:00:00 2001 From: pyos Date: Thu, 2 Sep 2021 19:38:25 +0200 Subject: [PATCH] FIR: rename type parameter: Annotation -> TAnnotation --- ...AbstractAnnotationTypeQualifierResolver.kt | 44 +++++++++---------- .../typeEnhancement/AbstractSignatureParts.kt | 10 ++--- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt index d9db1526f4a..078d01904c6 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AbstractAnnotationTypeQualifierResolver.kt @@ -13,25 +13,25 @@ import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMi import org.jetbrains.kotlin.name.FqName import java.util.concurrent.ConcurrentHashMap -private typealias TypeQualifierWithApplicability = Pair> +private typealias TypeQualifierWithApplicability = Pair> -abstract class AbstractAnnotationTypeQualifierResolver( +abstract class AbstractAnnotationTypeQualifierResolver( private val javaTypeEnhancementState: JavaTypeEnhancementState ) { - protected abstract val Annotation.annotations: Iterable - protected abstract val Annotation.key: Any // TODO: figure out if keying `resolvedNicknames` by `fqName` is safe - protected abstract val Annotation.fqName: FqName? - protected abstract fun Annotation.enumArguments(onlyValue: Boolean): Iterable + protected abstract val TAnnotation.annotations: Iterable + protected abstract val TAnnotation.key: Any // TODO: figure out if keying `resolvedNicknames` by `fqName` is safe + protected abstract val TAnnotation.fqName: FqName? + protected abstract fun TAnnotation.enumArguments(onlyValue: Boolean): Iterable - private fun Annotation.findAnnotation(fqName: FqName): Annotation? = + private fun TAnnotation.findAnnotation(fqName: FqName): TAnnotation? = annotations.find { it.fqName == fqName } - private fun Annotation.hasAnnotation(fqName: FqName): Boolean = + private fun TAnnotation.hasAnnotation(fqName: FqName): Boolean = annotations.any { it.fqName == fqName } - private val resolvedNicknames = ConcurrentHashMap() + private val resolvedNicknames = ConcurrentHashMap() - fun resolveTypeQualifierAnnotation(annotation: Annotation): Annotation? { + fun resolveTypeQualifierAnnotation(annotation: TAnnotation): TAnnotation? { if (javaTypeEnhancementState.jsr305.isDisabled) return null if (annotation.fqName in BUILT_IN_TYPE_QUALIFIER_FQ_NAMES || annotation.hasAnnotation(TYPE_QUALIFIER_FQNAME)) return annotation @@ -44,7 +44,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( } } - private fun resolveQualifierBuiltInDefaultAnnotation(annotation: Annotation): JavaDefaultQualifiers? { + private fun resolveQualifierBuiltInDefaultAnnotation(annotation: TAnnotation): JavaDefaultQualifiers? { if (javaTypeEnhancementState.disabledDefaultAnnotations) { return null } @@ -57,7 +57,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( } } - private fun resolveDefaultAnnotationState(annotation: Annotation): ReportLevel { + private fun resolveDefaultAnnotationState(annotation: TAnnotation): ReportLevel { val annotationFqname = annotation.fqName if (annotationFqname != null && annotationFqname in JSPECIFY_DEFAULT_ANNOTATIONS) { return javaTypeEnhancementState.getReportLevelForAnnotation(annotationFqname) @@ -73,7 +73,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( else this - private fun resolveTypeQualifierDefaultAnnotation(annotation: Annotation): TypeQualifierWithApplicability? { + private fun resolveTypeQualifierDefaultAnnotation(annotation: TAnnotation): TypeQualifierWithApplicability? { if (javaTypeEnhancementState.jsr305.isDisabled) return null val typeQualifierDefault = annotation.findAnnotation(TYPE_QUALIFIER_DEFAULT_FQNAME) ?: return null val typeQualifier = annotation.annotations.firstOrNull { resolveTypeQualifierAnnotation(it) != null } ?: return null @@ -82,18 +82,18 @@ abstract class AbstractAnnotationTypeQualifierResolver( return TypeQualifierWithApplicability(typeQualifier, applicability.allIfTypeUse()) } - fun isTypeUseAnnotation(annotation: Annotation): Boolean { + fun isTypeUseAnnotation(annotation: TAnnotation): Boolean { // Expect that Java's Target was mapped to Kotlin's Target. val target = annotation.findAnnotation(StandardNames.FqNames.target) ?: return false return target.enumArguments(onlyValue = false).any { it == KotlinTarget.TYPE.name } } - private fun resolveJsr305AnnotationState(annotation: Annotation): ReportLevel { + private fun resolveJsr305AnnotationState(annotation: TAnnotation): ReportLevel { resolveJsr305CustomState(annotation)?.let { return it } return javaTypeEnhancementState.jsr305.globalLevel } - private fun resolveJsr305CustomState(annotation: Annotation): ReportLevel? { + private fun resolveJsr305CustomState(annotation: TAnnotation): ReportLevel? { javaTypeEnhancementState.jsr305.userDefinedLevelForSpecificAnnotation[annotation.fqName]?.let { return it } val enumValue = annotation.findAnnotation(MIGRATION_ANNOTATION_FQNAME)?.enumArguments(onlyValue = false)?.firstOrNull() ?: return null @@ -106,7 +106,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( } private fun extractNullability( - annotation: Annotation, forceWarning: Annotation.() -> Boolean + annotation: TAnnotation, forceWarning: TAnnotation.() -> Boolean ): NullabilityQualifierWithMigrationStatus? { knownNullability(annotation, annotation.forceWarning())?.let { return it } @@ -119,11 +119,11 @@ abstract class AbstractAnnotationTypeQualifierResolver( } fun extractNullability( - annotations: Iterable, forceWarning: Annotation.() -> Boolean = { false } + annotations: Iterable, forceWarning: TAnnotation.() -> Boolean = { false } ): NullabilityQualifierWithMigrationStatus? = annotations.firstNotNullOfOrNull { extractNullability(it, forceWarning) } - fun extractMutability(annotations: Iterable): MutabilityQualifier? { + fun extractMutability(annotations: Iterable): MutabilityQualifier? { return annotations.fold(null as MutabilityQualifier?) { found, annotation -> when (annotation.fqName) { in READ_ONLY_ANNOTATIONS -> MutabilityQualifier.READ_ONLY @@ -133,7 +133,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( } } - private fun extractDefaultQualifiers(annotation: Annotation): JavaDefaultQualifiers? { + private fun extractDefaultQualifiers(annotation: TAnnotation): JavaDefaultQualifiers? { resolveQualifierBuiltInDefaultAnnotation(annotation)?.let { return it } val (typeQualifier, applicability) = resolveTypeQualifierDefaultAnnotation(annotation) @@ -147,7 +147,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( } fun extractAndMergeDefaultQualifiers( - oldQualifiers: JavaTypeQualifiersByElementType?, annotations: Iterable + oldQualifiers: JavaTypeQualifiersByElementType?, annotations: Iterable ): JavaTypeQualifiersByElementType? { if (javaTypeEnhancementState.disabledDefaultAnnotations) return oldQualifiers @@ -169,7 +169,7 @@ abstract class AbstractAnnotationTypeQualifierResolver( return if (!wasUpdate) oldQualifiers else JavaTypeQualifiersByElementType(defaultQualifiersByType) } - private fun knownNullability(annotation: Annotation, forceWarning: Boolean): NullabilityQualifierWithMigrationStatus? { + private fun knownNullability(annotation: TAnnotation, forceWarning: Boolean): NullabilityQualifierWithMigrationStatus? { val fqName = annotation.fqName ?: return null val reportLevel = javaTypeEnhancementState.getReportLevelForAnnotation(fqName) if (reportLevel.isIgnore) return null diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt index 74354c35e85..8894dd9546e 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/AbstractSignatureParts.kt @@ -15,11 +15,11 @@ import org.jetbrains.kotlin.types.model.TypeParameterMarker import org.jetbrains.kotlin.types.model.TypeSystemContext import org.jetbrains.kotlin.types.model.TypeVariance -abstract class AbstractSignatureParts { +abstract class AbstractSignatureParts { // TODO: some of this might be better off as parameters - abstract val annotationTypeQualifierResolver: AbstractAnnotationTypeQualifierResolver + abstract val annotationTypeQualifierResolver: AbstractAnnotationTypeQualifierResolver abstract val enableImprovementsInStrictMode: Boolean - abstract val containerAnnotations: Iterable + abstract val containerAnnotations: Iterable abstract val containerApplicabilityType: AnnotationQualifierApplicabilityType abstract val containerDefaultTypeQualifiers: JavaTypeQualifiersByElementType? abstract val containerIsVarargParameter: Boolean @@ -30,9 +30,9 @@ abstract class AbstractSignatureParts { open val forceOnlyHeadTypeConstructor: Boolean get() = false - abstract val Annotation.forceWarning: Boolean + abstract val TAnnotation.forceWarning: Boolean - abstract val KotlinTypeMarker.annotations: Iterable + abstract val KotlinTypeMarker.annotations: Iterable abstract val KotlinTypeMarker.enhancedForWarnings: KotlinTypeMarker? abstract val KotlinTypeMarker.fqNameUnsafe: FqNameUnsafe? abstract fun KotlinTypeMarker.isEqual(other: KotlinTypeMarker): Boolean