From 6c37574fcefb721f8142b3651dae17e9b9e592e1 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Wed, 14 Aug 2019 12:54:55 +0300 Subject: [PATCH] Rename Jsr305State -> JavaTypeEnhancementState Also, rename some of the properties It's needed to store status for codeanalysis annotation in that class --- .../cli/common/arguments/Jsr305Parser.kt | 10 +++---- .../kotlin/config/JvmAnalysisFlags.kt | 6 ++--- .../enhancement/EnhancementSignatureParts.kt | 26 +++++++++---------- .../FirAnnotationTypeQualifierResolver.kt | 18 ++++++------- .../enhancement/FirJavaEnhancementContext.kt | 14 +++++----- .../enhancement/FirJsr305StateContainer.kt | 6 ++--- .../java/enhancement/SignatureEnhancement.kt | 4 +-- .../fir/java/enhancement/nullabilityUtils.kt | 18 ++++++------- .../org/jetbrains/kotlin/fir/FirSession.kt | 5 +++- .../codeanalysis/wildcardsWithDefault.txt | 2 +- .../AbstractForeignAnnotationsTest.kt | 4 +-- .../LoadJavaPackageAnnotationsTest.kt | 4 +-- .../TypeQualifierAnnotationResolverTest.kt | 4 +-- compiler/util/build.gradle.kts | 2 ++ .../jetbrains/kotlin/config/AnalysisFlag.kt | 9 +++++++ .../jetbrains/kotlin/config/JvmDefaultMode.kt | 2 +- .../java/AnnotationTypeQualifierResolver.kt | 18 ++++++------- .../typeEnhancement/signatureEnhancement.kt | 8 +++--- .../runtime/components/RuntimeModuleData.kt | 6 ++--- ...05State.kt => JavaTypeEnhancementState.kt} | 24 ++++++++--------- .../compiler/IDELanguageSettingsProvider.kt | 8 +++--- .../jetbrains/kotlin/idea/project/Platform.kt | 6 ++--- 22 files changed, 109 insertions(+), 95 deletions(-) rename compiler/{config.jvm => util}/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt (92%) rename core/util.runtime/src/org/jetbrains/kotlin/utils/{Jsr305State.kt => JavaTypeEnhancementState.kt} (59%) diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/Jsr305Parser.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/Jsr305Parser.kt index ee728444e62..83f33d52a84 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/Jsr305Parser.kt +++ b/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?, supportCompatqualCheckerFrameworkAnnotations: String?): Jsr305State { + fun parse(value: Array?, supportCompatqualCheckerFrameworkAnnotations: String?): JavaTypeEnhancementState { var global: ReportLevel? = null var migration: ReportLevel? = null val userDefined = mutableMapOf() @@ -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) { diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt index b6626b5b53a..ff97c379699 100644 --- a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt +++ b/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 = - AnalysisFlag.Delegate(property.name, Jsr305State.DEFAULT) + operator fun provideDelegate(instance: Any?, property: KProperty<*>): AnalysisFlag.Delegate = + AnalysisFlag.Delegate(property.name, JavaTypeEnhancementState.DEFAULT) } object JvmDefaultModeDisabledByDefault { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt index 1d61b3a3473..86cdbc8d4e3 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/EnhancementSignatureParts.kt +++ b/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 { val list = ArrayList(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, 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 { - val indexedFromSupertypes = fromOverridden.map { it.toIndexed(typeQualifierResolver, jsr305State, context) } - val indexedThisType = current.toIndexed(typeQualifierResolver, jsr305State, context) + private fun computeIndexedQualifiersForOverride(session: FirSession, javaTypeEnhancementState: JavaTypeEnhancementState): IndexedJavaTypeQualifiers { + val indexedFromSupertypes = fromOverridden.map { it.toIndexed(typeQualifierResolver, javaTypeEnhancementState, context) } + val indexedThisType = current.toIndexed(typeQualifierResolver, javaTypeEnhancementState, context) // The covariant case may be hard, e.g. in the superclass the return may be Super, but in the subclass it may be Derived, which // is declared to extend Super, 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) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt index 2a949fd12bf..2f09829e741 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirAnnotationTypeQualifierResolver.kt +++ b/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 } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt index ccfdcd3b83e..58586434e6a 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJavaEnhancementContext.kt +++ b/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 ): 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 ): FirJavaEnhancementContext = when { additionalAnnotations.isEmpty() -> this else -> FirJavaEnhancementContext(session) { - computeNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, additionalAnnotations) + computeNewDefaultTypeQualifiers(typeQualifierResolver, javaTypeEnhancementState, additionalAnnotations) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJsr305StateContainer.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJsr305StateContainer.kt index b3477afae5e..da176be43bd 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/FirJsr305StateContainer.kt +++ b/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) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt index fe44a7f7206..751c0639d8f 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt +++ b/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) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt index 0b28ca1b22b..c70e1bf9f70 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/nullabilityUtils.kt +++ b/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.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( diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSession.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSession.kt index 3c713e60af8..aefdd736477 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSession.kt +++ b/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 = Companion diff --git a/compiler/testData/foreignAnnotationsJava8/tests/codeanalysis/wildcardsWithDefault.txt b/compiler/testData/foreignAnnotationsJava8/tests/codeanalysis/wildcardsWithDefault.txt index a15fa4185c5..bd6159aff27 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/codeanalysis/wildcardsWithDefault.txt +++ b/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): kotlin.Unit + @jspecify.annotations.DefaultNotNull public open fun noBoundsNotNull(/*0*/ a: A): kotlin.Unit @jspecify.annotations.DefaultNullable public open fun noBoundsNullable(/*0*/ a: A?): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt index ab334abd540..be8a731b845 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt +++ b/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.getDirectiveValue(directive: String): ReportLevel? = mapNotNull { diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt index 8838187f287..7b2125d3c1e 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt +++ b/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) } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt index be11840a16c..c096d86a156 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt +++ b/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) ) } diff --git a/compiler/util/build.gradle.kts b/compiler/util/build.gradle.kts index 0795c093dd8..e721a7c0c62 100644 --- a/compiler/util/build.gradle.kts +++ b/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) } diff --git a/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt b/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt index 4d1a20ddfb1..90788074b19 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt +++ b/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 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()) } diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt b/compiler/util/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt similarity index 92% rename from compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt rename to compiler/util/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt index 299209d2e7d..0224be5045a 100644 --- a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmDefaultMode.kt +++ b/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. */ diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt index 0f5bdd0015f..7a9bd95e993 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt +++ b/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 diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 5fca4049c8a..ccf5f93bb3f 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/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( diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/components/RuntimeModuleData.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/components/RuntimeModuleData.kt index 798a67004b9..b333e3df3df 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/components/RuntimeModuleData.kt +++ b/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 ) diff --git a/core/util.runtime/src/org/jetbrains/kotlin/utils/Jsr305State.kt b/core/util.runtime/src/org/jetbrains/kotlin/utils/JavaTypeEnhancementState.kt similarity index 59% rename from core/util.runtime/src/org/jetbrains/kotlin/utils/Jsr305State.kt rename to core/util.runtime/src/org/jetbrains/kotlin/utils/JavaTypeEnhancementState.kt index 7602d4c1442..adc1ac25dc4 100644 --- a/core/util.runtime/src/org/jetbrains/kotlin/utils/Jsr305State.kt +++ b/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( - val global: ReportLevel, - val migration: ReportLevel?, - val user: Map, - val enableCompatqualCheckerFrameworkAnnotations: Boolean = COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE +class JavaTypeEnhancementState( + val globalJsr305Level: ReportLevel, + val migrationLevelForJsr305: ReportLevel?, + val userDefinedLevelForSpecificJsr305Annotation: Map, + val enableCompatqualCheckerFrameworkAnnotations: Boolean = COMPATQUAL_CHECKER_FRAMEWORK_ANNOTATIONS_SUPPORT_DEFAULT_VALUE ) { val description: Array by lazy { val result = mutableListOf() - 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()) } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IDELanguageSettingsProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IDELanguageSettingsProvider.kt index 85c52fdb5bf..e684b1fb102 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IDELanguageSettingsProvider.kt +++ b/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? { - var result: Jsr305State? = null + private fun computeJavaTypeEnhancementState(project: Project): JavaTypeEnhancementState? { + 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 diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt index 4aef8ab4f40..bec47c5008d 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt +++ b/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) }