From c255da815f639d0dea92bbb73ad1557a2a6a2b35 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 25 Jan 2022 11:45:35 +0300 Subject: [PATCH] Change some names in source code from useExperimental to optIn --- .../FirOptInAnnotationCallChecker.kt | 4 +-- ...entalMarkerDeclarationAnnotationChecker.kt | 10 +++---- .../checkers/ExperimentalUsageChecker.kt | 28 +++++++++---------- .../kotlin/resolve/checkers/OptInNames.kt | 18 ++++++++++-- 4 files changed, 37 insertions(+), 23 deletions(-) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt index 67fb00d1337..61c6048f9ae 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInAnnotationCallChecker.kt @@ -58,9 +58,9 @@ object FirOptInAnnotationCallChecker : FirAnnotationCallChecker() { reporter: DiagnosticReporter ) { val languageVersionSettings = context.session.languageVersionSettings - val useExperimentalFqNames = languageVersionSettings.getFlag(AnalysisFlags.optIn) + val optInFqNames = languageVersionSettings.getFlag(AnalysisFlags.optIn) if (!languageVersionSettings.supportsFeature(LanguageFeature.OptInRelease) && - OptInNames.REQUIRES_OPT_IN_FQ_NAME.asString() !in useExperimentalFqNames + OptInNames.REQUIRES_OPT_IN_FQ_NAME.asString() !in optInFqNames ) { reporter.reportOn(element, FirErrors.OPT_IN_IS_NOT_ENABLED, context) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt index 3830e95f30c..538a2ea0a91 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt @@ -47,18 +47,18 @@ class ExperimentalMarkerDeclarationAnnotationChecker(private val module: ModuleD for (entry in entries) { val annotation = trace.bindingContext.get(BindingContext.ANNOTATION, entry) ?: continue when (annotation.fqName) { - in OptInNames.USE_EXPERIMENTAL_FQ_NAMES -> { + in OptInNames.OPT_IN_FQ_NAMES -> { val annotationClasses = annotation.allValueArguments[OptInNames.USE_EXPERIMENTAL_ANNOTATION_CLASS] .safeAs()?.value.orEmpty() - checkUseExperimentalUsage(annotationClasses, trace, entry) + checkOptInUsage(annotationClasses, trace, entry) } - in OptInNames.EXPERIMENTAL_FQ_NAMES -> { + in OptInNames.REQUIRES_OPT_IN_FQ_NAMES -> { isAnnotatedWithExperimental = true } } val annotationClass = annotation.annotationClass ?: continue - if (annotationClass.annotations.any { it.fqName in OptInNames.EXPERIMENTAL_FQ_NAMES }) { + if (annotationClass.annotations.any { it.fqName in OptInNames.REQUIRES_OPT_IN_FQ_NAMES }) { val applicableTargets = AnnotationChecker.applicableTargetSet(annotationClass) val possibleTargets = applicableTargets.intersect(actualTargets) val annotationUseSiteTarget = entry.useSiteTarget?.getAnnotationUseSiteTarget() @@ -131,7 +131,7 @@ class ExperimentalMarkerDeclarationAnnotationChecker(private val module: ModuleD return false } - private fun checkUseExperimentalUsage(annotationClasses: List>, trace: BindingTrace, entry: KtAnnotationEntry) { + private fun checkOptInUsage(annotationClasses: List>, trace: BindingTrace, entry: KtAnnotationEntry) { if (annotationClasses.isEmpty()) { trace.report(Errors.OPT_IN_WITHOUT_ARGUMENTS.on(entry)) return diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt index 0c29481751a..06c11b58322 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt @@ -35,13 +35,13 @@ import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall -import org.jetbrains.kotlin.resolve.checkers.OptInNames.EXPERIMENTAL_FQ_NAMES +import org.jetbrains.kotlin.resolve.checkers.OptInNames.REQUIRES_OPT_IN_FQ_NAMES import org.jetbrains.kotlin.resolve.checkers.OptInNames.OLD_EXPERIMENTAL_FQ_NAME import org.jetbrains.kotlin.resolve.checkers.OptInNames.OLD_USE_EXPERIMENTAL_FQ_NAME import org.jetbrains.kotlin.resolve.checkers.OptInNames.OPT_IN_FQ_NAME import org.jetbrains.kotlin.resolve.checkers.OptInNames.REQUIRES_OPT_IN_FQ_NAME import org.jetbrains.kotlin.resolve.checkers.OptInNames.USE_EXPERIMENTAL_ANNOTATION_CLASS -import org.jetbrains.kotlin.resolve.checkers.OptInNames.USE_EXPERIMENTAL_FQ_NAMES +import org.jetbrains.kotlin.resolve.checkers.OptInNames.OPT_IN_FQ_NAMES import org.jetbrains.kotlin.resolve.checkers.OptInNames.WAS_EXPERIMENTAL_FQ_NAME import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.EnumValue @@ -303,7 +303,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { annotationFqName.asString() in languageVersionSettings.getFlag(AnalysisFlags.optIn) || anyParentMatches { element -> element.isDeclarationAnnotatedWith(annotationFqName, bindingContext) || - element.isElementAnnotatedWithUseExperimentalOf(annotationFqName, bindingContext) + element.isElementAnnotatedWithOptIn(annotationFqName, bindingContext) } private fun PsiElement.isDeclarationAnnotatedWith(annotationFqName: FqName, bindingContext: BindingContext): Boolean { @@ -313,10 +313,10 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { return descriptor != null && descriptor.annotations.hasAnnotation(annotationFqName) } - private fun PsiElement.isElementAnnotatedWithUseExperimentalOf(annotationFqName: FqName, bindingContext: BindingContext): Boolean { + private fun PsiElement.isElementAnnotatedWithOptIn(annotationFqName: FqName, bindingContext: BindingContext): Boolean { return this is KtAnnotated && annotationEntries.any { entry -> val descriptor = bindingContext.get(BindingContext.ANNOTATION, entry) - if (descriptor != null && descriptor.fqName in USE_EXPERIMENTAL_FQ_NAMES) { + if (descriptor != null && descriptor.fqName in OPT_IN_FQ_NAMES) { val annotationClasses = descriptor.allValueArguments[USE_EXPERIMENTAL_ANNOTATION_CLASS] annotationClasses is ArrayValue && annotationClasses.value.any { annotationClass -> annotationClass is KClassValue && annotationClass.value.let { value -> @@ -391,8 +391,8 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { name == OLD_USE_EXPERIMENTAL_FQ_NAME.shortName() || name == OPT_IN_FQ_NAME.shortName() ) { val fqName = targetDescriptor.fqNameSafe - if (fqName in EXPERIMENTAL_FQ_NAMES || fqName in USE_EXPERIMENTAL_FQ_NAMES) { - checkUsageOfKotlinExperimentalOrUseExperimental(element, context) + if (fqName in REQUIRES_OPT_IN_FQ_NAMES || fqName in OPT_IN_FQ_NAMES) { + checkUsageOfKotlinExperimentalOrOptIn(element, context) return } } @@ -404,7 +404,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { } if (targetClass != null && targetClass.loadExperimentalityForMarkerAnnotation() != null) { if (!element.isUsageAsAnnotationOrImport() && - !element.isUsageAsUseExperimentalArgument(context.trace.bindingContext) + !element.isUsageAsOptInArgument(context.trace.bindingContext) ) { context.trace.report( Errors.OPT_IN_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_OPT_IN.on(element) @@ -426,11 +426,11 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { } } - private fun checkUsageOfKotlinExperimentalOrUseExperimental(element: PsiElement, context: CheckerContext) { - val useExperimentalFqNames = context.languageVersionSettings.getFlag(AnalysisFlags.optIn) + private fun checkUsageOfKotlinExperimentalOrOptIn(element: PsiElement, context: CheckerContext) { + val optInFqNames = context.languageVersionSettings.getFlag(AnalysisFlags.optIn) if (!context.languageVersionSettings.supportsFeature(LanguageFeature.OptInRelease) && - REQUIRES_OPT_IN_FQ_NAME.asString() !in useExperimentalFqNames && - OLD_EXPERIMENTAL_FQ_NAME.asString() !in useExperimentalFqNames + REQUIRES_OPT_IN_FQ_NAME.asString() !in optInFqNames && + OLD_EXPERIMENTAL_FQ_NAME.asString() !in optInFqNames ) { context.trace.report(Errors.OPT_IN_IS_NOT_ENABLED.on(element)) } @@ -451,7 +451,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { return false } - private fun PsiElement.isUsageAsUseExperimentalArgument(bindingContext: BindingContext): Boolean { + private fun PsiElement.isUsageAsOptInArgument(bindingContext: BindingContext): Boolean { val qualifier = (this as? KtSimpleNameExpression)?.getTopmostParentQualifiedExpressionForSelector() ?: this val parent = qualifier.parent @@ -460,7 +460,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { parent.parent.parent is KtValueArgumentList && parent.parent.parent.parent.let { entry -> entry is KtAnnotationEntry && bindingContext.get(BindingContext.ANNOTATION, entry)?.let { annotation -> - annotation.fqName in USE_EXPERIMENTAL_FQ_NAMES || annotation.fqName == WAS_EXPERIMENTAL_FQ_NAME + annotation.fqName in OPT_IN_FQ_NAMES || annotation.fqName == WAS_EXPERIMENTAL_FQ_NAME } == true } } diff --git a/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/OptInNames.kt b/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/OptInNames.kt index 16bf891bf9b..47769f356eb 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/OptInNames.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/resolve/checkers/OptInNames.kt @@ -22,6 +22,20 @@ object OptInNames { val USE_EXPERIMENTAL_ANNOTATION_CLASS = Name.identifier("markerClass") val WAS_EXPERIMENTAL_ANNOTATION_CLASS = Name.identifier("markerClass") - val EXPERIMENTAL_FQ_NAMES = setOf(OLD_EXPERIMENTAL_FQ_NAME, REQUIRES_OPT_IN_FQ_NAME) - val USE_EXPERIMENTAL_FQ_NAMES = setOf(OLD_USE_EXPERIMENTAL_FQ_NAME, OPT_IN_FQ_NAME) + val REQUIRES_OPT_IN_FQ_NAMES = setOf(OLD_EXPERIMENTAL_FQ_NAME, REQUIRES_OPT_IN_FQ_NAME) + val OPT_IN_FQ_NAMES = setOf(OLD_USE_EXPERIMENTAL_FQ_NAME, OPT_IN_FQ_NAME) + + @Deprecated( + message = "EXPERIMENTAL_FQ_NAMES is deprecated, please use REQUIRES_OPT_IN_FQ_NAMES instead", + ReplaceWith("REQUIRES_OPT_IN_FQ_NAMES", imports = ["org.jetbrains.kotlin.resolve.checkers.OptInNames.REQUIRES_OPT_IN_FQ_NAMES"]) + ) + @Suppress("unused") + val EXPERIMENTAL_FQ_NAMES = REQUIRES_OPT_IN_FQ_NAMES + + @Deprecated( + message = "USE_EXPERIMENTAL_FQ_NAMES is deprecated, please use OPT_IN_FQ_NAMES instead", + ReplaceWith("OPT_IN_FQ_NAMES", imports = ["org.jetbrains.kotlin.resolve.checkers.OptInNames.OPT_IN_FQ_NAMES"]) + ) + @Suppress("unused") + val USE_EXPERIMENTAL_FQ_NAMES = OPT_IN_FQ_NAMES } \ No newline at end of file