From cdbabf224f35609b3fd90d607432d33259f67a08 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 13 Dec 2019 21:11:48 +0300 Subject: [PATCH] Introduce RequiresOptIn and OptIn annotations RequiresOptIn should be used now instead of Experimental, OptIn instead of UseExperimental. See https://github.com/Kotlin/KEEP/pull/201. This change adds the new declarations only to the stdlib, and supports them in the compiler. Because of the way compiler loads annotations, we need to bootstrap it first before deprecating the old annotations and updating tests. #KT-34647 Fixed --- .../rendering/DefaultErrorMessages.java | 16 +++--- ...entalMarkerDeclarationAnnotationChecker.kt | 8 ++- .../checkers/ExperimentalUsageChecker.kt | 36 +++++++----- .../OverrideMemberChooserObject.kt | 4 +- .../idea/quickfix/ExperimentalFixesFactory.kt | 6 +- .../quickfix/MakeModuleExperimentalFix.kt | 6 +- .../expectactual/ExpectActualUtils.kt | 10 +++- libraries/stdlib/js/src/kotlin/annotations.kt | 1 + .../annotations/ExperimentalStdlibApi.kt | 1 + .../src/kotlin/annotations/Multiplatform.kt | 1 + .../stdlib/src/kotlin/annotations/OptIn.kt | 55 +++++++++++++++++++ .../src/kotlin/contracts/ContractBuilder.kt | 3 +- .../kotlin/experimental/inferenceMarker.kt | 1 + .../src/kotlin/time/ExperimentalTime.kt | 3 +- .../src/kotlin/annotations/Unsigned.kt | 1 + .../targets/js/dsl/ExperimentalDceDsl.kt | 3 +- .../js/dsl/ExperimentalDistributionDsl.kt | 3 +- 17 files changed, 119 insertions(+), 39 deletions(-) create mode 100644 libraries/stdlib/src/kotlin/annotations/OptIn.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 127e05f56b8..2ea34c47759 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -147,22 +147,22 @@ public class DefaultErrorMessages { MAP.put(ILLEGAL_KOTLIN_VERSION_STRING_VALUE, "Invalid @{0} annotation value (should be ''major.minor'' or ''major.minor.patch'')", TO_STRING); MAP.put(NEWER_VERSION_IN_SINCE_KOTLIN, "The version is greater than the specified API version {0}", STRING); - MAP.put(EXPERIMENTAL_API_USAGE, "This declaration is experimental and its usage should be marked with ''@{0}'' or ''@UseExperimental({0}::class)''", TO_STRING); - MAP.put(EXPERIMENTAL_API_USAGE_ERROR, "This declaration is experimental and its usage must be marked with ''@{0}'' or ''@UseExperimental({0}::class)''", TO_STRING); + MAP.put(EXPERIMENTAL_API_USAGE, "This declaration is experimental and its usage should be marked with ''@{0}'' or ''@OptIn({0}::class)''", TO_STRING); + MAP.put(EXPERIMENTAL_API_USAGE_ERROR, "This declaration is experimental and its usage must be marked with ''@{0}'' or ''@OptIn({0}::class)''", TO_STRING); MAP.put(EXPERIMENTAL_OVERRIDE, "This declaration overrides experimental member of supertype ''{1}'' and should be annotated with ''@{0}''", TO_STRING, NAME); MAP.put(EXPERIMENTAL_OVERRIDE_ERROR, "This declaration overrides experimental member of supertype ''{1}'' and must be annotated with ''@{0}''", TO_STRING, NAME); - MAP.put(EXPERIMENTAL_IS_NOT_ENABLED, "This class can only be used with the compiler argument '-Xuse-experimental=kotlin.Experimental'"); + MAP.put(EXPERIMENTAL_IS_NOT_ENABLED, "This class can only be used with the compiler argument '-Xopt-in=kotlin.RequiresOptIn'"); MAP.put(EXPERIMENTAL_CAN_ONLY_BE_USED_AS_ANNOTATION, "This class can only be used as an annotation"); - MAP.put(EXPERIMENTAL_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_USE_EXPERIMENTAL, "This class can only be used as an annotation or as an argument to @UseExperimental"); + MAP.put(EXPERIMENTAL_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_USE_EXPERIMENTAL, "This class can only be used as an annotation or as an argument to @OptIn"); - MAP.put(USE_EXPERIMENTAL_WITHOUT_ARGUMENTS, "@UseExperimental without any arguments has no effect"); - MAP.put(USE_EXPERIMENTAL_ARGUMENT_IS_NOT_MARKER, "Annotation ''{0}'' is not an experimental API marker, therefore its usage in @UseExperimental is ignored", TO_STRING); + MAP.put(USE_EXPERIMENTAL_WITHOUT_ARGUMENTS, "@OptIn without any arguments has no effect"); + MAP.put(USE_EXPERIMENTAL_ARGUMENT_IS_NOT_MARKER, "Annotation ''{0}'' is not an experimental API marker, therefore its usage in @OptIn is ignored", TO_STRING); MAP.put(EXPERIMENTAL_ANNOTATION_WITH_WRONG_TARGET, "Experimental annotation cannot be used on the following code elements: {0}. Please remove these targets", STRING); - MAP.put(EXPERIMENTAL_UNSIGNED_LITERALS, "Unsigned literals are experimental and their usages should be marked with ''@{0}'' or ''@UseExperimental({0}::class)''", TO_STRING); - MAP.put(EXPERIMENTAL_UNSIGNED_LITERALS_ERROR, "Unsigned literals are experimental and their usages must be marked with ''@{0}'' or ''@UseExperimental({0}::class)''", TO_STRING); + MAP.put(EXPERIMENTAL_UNSIGNED_LITERALS, "Unsigned literals are experimental and their usages should be marked with ''@{0}'' or ''@OptIn({0}::class)''", TO_STRING); + MAP.put(EXPERIMENTAL_UNSIGNED_LITERALS_ERROR, "Unsigned literals are experimental and their usages must be marked with ''@{0}'' or ''@OptIn({0}::class)''", TO_STRING); MAP.put(NON_PARENTHESIZED_ANNOTATIONS_ON_FUNCTIONAL_TYPES, "Non-parenthesized annotations on function types without receiver aren't yet supported (see KT-31734 for details)"); 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 cb858eb0849..91ff45e0983 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.KClassValue import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.utils.addToStdlib.safeAs class ExperimentalMarkerDeclarationAnnotationChecker(private val module: ModuleDescriptor) : AdditionalAnnotationChecker { private val WRONG_TARGETS_FOR_MARKER = setOf(KotlinTarget.EXPRESSION, KotlinTarget.FILE) @@ -29,12 +30,13 @@ class ExperimentalMarkerDeclarationAnnotationChecker(private val module: ModuleD for (entry in entries) { val annotation = trace.bindingContext.get(BindingContext.ANNOTATION, entry) when (annotation?.fqName) { - ExperimentalUsageChecker.USE_EXPERIMENTAL_FQ_NAME -> { + in ExperimentalUsageChecker.USE_EXPERIMENTAL_FQ_NAMES -> { val annotationClasses = - (annotation.allValueArguments[ExperimentalUsageChecker.USE_EXPERIMENTAL_ANNOTATION_CLASS] as? ArrayValue)?.value.orEmpty() + annotation!!.allValueArguments[ExperimentalUsageChecker.USE_EXPERIMENTAL_ANNOTATION_CLASS] + .safeAs()?.value.orEmpty() checkUseExperimentalUsage(annotationClasses, trace, entry) } - ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAME -> { + in ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAMES -> { isAnnotatedWithExperimental = true } } 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 b11737e502e..7a2a14af573 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt @@ -43,7 +43,6 @@ import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver import org.jetbrains.kotlin.resolve.deprecation.DeprecationSettings import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.utils.SmartSet @@ -72,8 +71,14 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { } companion object { - val EXPERIMENTAL_FQ_NAME = FqName("kotlin.Experimental") - val USE_EXPERIMENTAL_FQ_NAME = FqName("kotlin.UseExperimental") + val OLD_EXPERIMENTAL_FQ_NAME = FqName("kotlin.Experimental") + val OLD_USE_EXPERIMENTAL_FQ_NAME = FqName("kotlin.UseExperimental") + val REQUIRES_OPT_IN_FQ_NAME = FqName("kotlin.RequiresOptIn") + val OPT_IN_FQ_NAME = FqName("kotlin.OptIn") + + 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) + internal val WAS_EXPERIMENTAL_FQ_NAME = FqName("kotlin.WasExperimental") internal val USE_EXPERIMENTAL_ANNOTATION_CLASS = Name.identifier("markerClass") internal val WAS_EXPERIMENTAL_ANNOTATION_CLASS = Name.identifier("markerClass") @@ -82,9 +87,6 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { private val WARNING_LEVEL = Name.identifier("WARNING") private val ERROR_LEVEL = Name.identifier("ERROR") - private val EXPERIMENTAL_SHORT_NAME = EXPERIMENTAL_FQ_NAME.shortName() - private val USE_EXPERIMENTAL_SHORT_NAME = USE_EXPERIMENTAL_FQ_NAME.shortName() - private val EXPERIMENTAL_API_DIAGNOSTICS = ExperimentalityDiagnostics( Errors.EXPERIMENTAL_API_USAGE, Errors.EXPERIMENTAL_API_USAGE_ERROR ) @@ -146,7 +148,10 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { } internal fun ClassDescriptor.loadExperimentalityForMarkerAnnotation(): Experimentality? { - val experimental = annotations.findAnnotation(EXPERIMENTAL_FQ_NAME) ?: return null + val experimental = + annotations.findAnnotation(REQUIRES_OPT_IN_FQ_NAME) + ?: annotations.findAnnotation(OLD_EXPERIMENTAL_FQ_NAME) + ?: return null val severity = when ((experimental.allValueArguments[LEVEL] as? EnumValue)?.enumEntryName) { WARNING_LEVEL -> Experimentality.Severity.WARNING @@ -187,7 +192,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { private fun PsiElement.isElementAnnotatedWithUseExperimentalOf(annotationFqName: FqName, bindingContext: BindingContext): Boolean { return this is KtAnnotated && annotationEntries.any { entry -> val descriptor = bindingContext.get(BindingContext.ANNOTATION, entry) - if (descriptor?.fqName == USE_EXPERIMENTAL_FQ_NAME) { + if (descriptor != null && descriptor.fqName in USE_EXPERIMENTAL_FQ_NAMES) { val annotationClasses = descriptor.allValueArguments[USE_EXPERIMENTAL_ANNOTATION_CLASS] annotationClasses is ArrayValue && annotationClasses.value.any { annotationClass -> annotationClass is KClassValue && annotationClass.value.let { value -> @@ -244,7 +249,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { val validExperimental = languageVersionSettings.getFlag(AnalysisFlags.experimental).filter(::checkAnnotation) val validUseExperimental = languageVersionSettings.getFlag(AnalysisFlags.useExperimental).filter { fqName -> - fqName == EXPERIMENTAL_FQ_NAME.asString() || checkAnnotation(fqName) + fqName == REQUIRES_OPT_IN_FQ_NAME.asString() || fqName == OLD_EXPERIMENTAL_FQ_NAME.asString() || checkAnnotation(fqName) } for (fqName in validExperimental.intersect(validUseExperimental)) { @@ -258,9 +263,10 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { override fun check(targetDescriptor: ClassifierDescriptor, element: PsiElement, context: ClassifierUsageCheckerContext) { val name = targetDescriptor.name - if (name == EXPERIMENTAL_SHORT_NAME || name == USE_EXPERIMENTAL_SHORT_NAME) { - val fqName = targetDescriptor.fqNameUnsafe - if (fqName == EXPERIMENTAL_FQ_NAME.toUnsafe() || fqName == USE_EXPERIMENTAL_FQ_NAME.toUnsafe()) { + if (name == OLD_EXPERIMENTAL_FQ_NAME.shortName() || name == REQUIRES_OPT_IN_FQ_NAME.shortName() || + 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) return } @@ -288,7 +294,9 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { } private fun checkUsageOfKotlinExperimentalOrUseExperimental(element: PsiElement, context: CheckerContext) { - if (EXPERIMENTAL_FQ_NAME.asString() !in context.languageVersionSettings.getFlag(AnalysisFlags.useExperimental)) { + val useExperimentalFqNames = context.languageVersionSettings.getFlag(AnalysisFlags.useExperimental) + if (REQUIRES_OPT_IN_FQ_NAME.asString() !in useExperimentalFqNames && + OLD_EXPERIMENTAL_FQ_NAME.asString() !in useExperimentalFqNames) { context.trace.report(Errors.EXPERIMENTAL_IS_NOT_ENABLED.on(element)) } @@ -317,7 +325,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 == USE_EXPERIMENTAL_FQ_NAME || annotation.fqName == WAS_EXPERIMENTAL_FQ_NAME + annotation.fqName in USE_EXPERIMENTAL_FQ_NAMES || annotation.fqName == WAS_EXPERIMENTAL_FQ_NAME } == true } } diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt index 7b3e506e7a7..50e487937e1 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt +++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt @@ -210,7 +210,9 @@ private val OVERRIDE_RENDERER = withOptions { typeNormalizer = IdeDescriptorRenderers.APPROXIMATE_FLEXIBLE_TYPES renderUnabbreviatedType = false annotationFilter = { - it.type.constructor.declarationDescriptor?.annotations?.hasAnnotation(ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAME) ?: false + val annotations = it.type.constructor.declarationDescriptor?.annotations + annotations != null && (annotations.hasAnnotation(ExperimentalUsageChecker.REQUIRES_OPT_IN_FQ_NAME) || + annotations.hasAnnotation(ExperimentalUsageChecker.OLD_EXPERIMENTAL_FQ_NAME)) } presentableUnresolvedTypes = true informativeErrorType = false diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ExperimentalFixesFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ExperimentalFixesFactory.kt index e48ac8829f8..77322d2d67d 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ExperimentalFixesFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ExperimentalFixesFactory.kt @@ -71,7 +71,7 @@ object ExperimentalFixesFactory : KotlinIntentionActionsFactory() { } result.add( AddAnnotationFix( - containingDeclaration, ExperimentalUsageChecker.USE_EXPERIMENTAL_FQ_NAME, suffix, annotationFqName + containingDeclaration, ExperimentalUsageChecker.OPT_IN_FQ_NAME, suffix, annotationFqName ) ) } @@ -84,7 +84,7 @@ object ExperimentalFixesFactory : KotlinIntentionActionsFactory() { } else { result.add( AddAnnotationFix( - containingClassOrObject, ExperimentalUsageChecker.USE_EXPERIMENTAL_FQ_NAME, suffix, annotationFqName + containingClassOrObject, ExperimentalUsageChecker.OPT_IN_FQ_NAME, suffix, annotationFqName ) ) } @@ -100,4 +100,4 @@ object ExperimentalFixesFactory : KotlinIntentionActionsFactory() { return result } -} \ No newline at end of file +} diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeModuleExperimentalFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeModuleExperimentalFix.kt index 9d24968432b..c6684f244b3 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeModuleExperimentalFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeModuleExperimentalFix.kt @@ -56,7 +56,7 @@ class MakeModuleExperimentalFix( val facet = KotlinFacet.get(module) ?: return true val facetSettings = facet.configuration.settings val compilerSettings = facetSettings.compilerSettings ?: return true - return if (annotationFqName != ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAME) { + return if (annotationFqName != ExperimentalUsageChecker.REQUIRES_OPT_IN_FQ_NAME) { compilerArgument !in compilerSettings.additionalArgumentsAsList } else { compilerSettings.additionalArgumentsAsList.none { @@ -69,7 +69,7 @@ class MakeModuleExperimentalFix( override fun createAction(diagnostic: Diagnostic): IntentionAction? { val containingKtFile = diagnostic.psiElement.containingFile as? KtFile ?: return null val module = containingKtFile.module ?: return null - return MakeModuleExperimentalFix(containingKtFile, module, ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAME) + return MakeModuleExperimentalFix(containingKtFile, module, ExperimentalUsageChecker.REQUIRES_OPT_IN_FQ_NAME) } } -} \ No newline at end of file +} diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/expectactual/ExpectActualUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/expectactual/ExpectActualUtils.kt index efda8fe5d54..e1d8f795770 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/expectactual/ExpectActualUtils.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/expectactual/ExpectActualUtils.kt @@ -32,8 +32,11 @@ import org.jetbrains.kotlin.idea.refactoring.createKotlinFile import org.jetbrains.kotlin.idea.refactoring.fqName.fqName import org.jetbrains.kotlin.idea.refactoring.introduce.showErrorHint import org.jetbrains.kotlin.idea.refactoring.isInterfaceClass -import org.jetbrains.kotlin.idea.util.* +import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers import org.jetbrains.kotlin.idea.util.application.runWriteAction +import org.jetbrains.kotlin.idea.util.hasInlineModifier +import org.jetbrains.kotlin.idea.util.isEffectivelyActual +import org.jetbrains.kotlin.idea.util.mustHaveValOrVar import org.jetbrains.kotlin.lexer.KtModifierKeywordToken import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.FqName @@ -259,7 +262,8 @@ private fun KtPsiFactory.repairSuperTypeList( private val forbiddenAnnotationFqNames = setOf( ExpectedActualDeclarationChecker.OPTIONAL_EXPECTATION_FQ_NAME, FqName("kotlin.ExperimentalMultiplatform"), - ExperimentalUsageChecker.USE_EXPERIMENTAL_FQ_NAME + ExperimentalUsageChecker.OPT_IN_FQ_NAME, + ExperimentalUsageChecker.OLD_USE_EXPERIMENTAL_FQ_NAME ) internal fun generateCallable( @@ -443,4 +447,4 @@ fun TypeAccessibilityChecker.findAndApplyExistingClasses(elements: Collection +) diff --git a/libraries/stdlib/src/kotlin/contracts/ContractBuilder.kt b/libraries/stdlib/src/kotlin/contracts/ContractBuilder.kt index 4dfd339e449..875a8545c5c 100644 --- a/libraries/stdlib/src/kotlin/contracts/ContractBuilder.kt +++ b/libraries/stdlib/src/kotlin/contracts/ContractBuilder.kt @@ -19,6 +19,7 @@ import kotlin.internal.InlineOnly @Retention(AnnotationRetention.BINARY) @SinceKotlin("1.3") @Experimental +@RequiresOptIn @MustBeDocumented public annotation class ExperimentalContracts @@ -147,4 +148,4 @@ public enum class InvocationKind { @InlineOnly @SinceKotlin("1.3") @Suppress("UNUSED_PARAMETER") -public inline fun contract(builder: ContractBuilder.() -> Unit) { } \ No newline at end of file +public inline fun contract(builder: ContractBuilder.() -> Unit) { } diff --git a/libraries/stdlib/src/kotlin/experimental/inferenceMarker.kt b/libraries/stdlib/src/kotlin/experimental/inferenceMarker.kt index 8e817fc601a..cd1075f70dd 100644 --- a/libraries/stdlib/src/kotlin/experimental/inferenceMarker.kt +++ b/libraries/stdlib/src/kotlin/experimental/inferenceMarker.kt @@ -13,6 +13,7 @@ package kotlin.experimental * or by using the compiler argument `-Xuse-experimental=kotlin.experimental.ExperimentalTypeInference`. */ @Experimental(level = Experimental.Level.ERROR) +@RequiresOptIn(level = RequiresOptIn.Level.ERROR) @MustBeDocumented @Retention(AnnotationRetention.BINARY) @Target(AnnotationTarget.ANNOTATION_CLASS) diff --git a/libraries/stdlib/src/kotlin/time/ExperimentalTime.kt b/libraries/stdlib/src/kotlin/time/ExperimentalTime.kt index 7b657c82c27..4220179dc29 100644 --- a/libraries/stdlib/src/kotlin/time/ExperimentalTime.kt +++ b/libraries/stdlib/src/kotlin/time/ExperimentalTime.kt @@ -19,6 +19,7 @@ import kotlin.annotation.AnnotationTarget.* * or by using the compiler argument `-Xuse-experimental=kotlin.time.ExperimentalTime`. */ @Experimental(level = Experimental.Level.ERROR) +@RequiresOptIn(level = RequiresOptIn.Level.ERROR) @MustBeDocumented @Retention(AnnotationRetention.BINARY) @Target( @@ -35,4 +36,4 @@ import kotlin.annotation.AnnotationTarget.* TYPEALIAS ) @SinceKotlin("1.3") -public annotation class ExperimentalTime \ No newline at end of file +public annotation class ExperimentalTime diff --git a/libraries/stdlib/unsigned/src/kotlin/annotations/Unsigned.kt b/libraries/stdlib/unsigned/src/kotlin/annotations/Unsigned.kt index d73731f7298..d61c6dc099e 100644 --- a/libraries/stdlib/unsigned/src/kotlin/annotations/Unsigned.kt +++ b/libraries/stdlib/unsigned/src/kotlin/annotations/Unsigned.kt @@ -20,6 +20,7 @@ import kotlin.internal.RequireKotlinVersionKind * It's recommended to propagate the experimental status to the API that depends on unsigned types by annotating it with this annotation. */ @Experimental(level = Experimental.Level.WARNING) +@RequiresOptIn(level = RequiresOptIn.Level.WARNING) @MustBeDocumented @Target(CLASS, ANNOTATION_CLASS, PROPERTY, FIELD, LOCAL_VARIABLE, VALUE_PARAMETER, CONSTRUCTOR, FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, TYPEALIAS) @Retention(AnnotationRetention.BINARY) diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDceDsl.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDceDsl.kt index 46cb07e05f8..01fc77d10f3 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDceDsl.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDceDsl.kt @@ -6,5 +6,6 @@ package org.jetbrains.kotlin.gradle.targets.js.dsl @Experimental(level = Experimental.Level.WARNING) +// TODO: @RequiresOptIn(level = RequiresOptIn.Level.WARNING) @Target(AnnotationTarget.FUNCTION) -annotation class ExperimentalDceDsl \ No newline at end of file +annotation class ExperimentalDceDsl diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDistributionDsl.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDistributionDsl.kt index fc9bdad096f..4074f046e98 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDistributionDsl.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDistributionDsl.kt @@ -6,5 +6,6 @@ package org.jetbrains.kotlin.gradle.targets.js.dsl @Experimental(level = Experimental.Level.WARNING) +// TODO: @RequiresOptIn(level = RequiresOptIn.Level.WARNING) @Target(AnnotationTarget.FUNCTION) -annotation class ExperimentalDistributionDsl \ No newline at end of file +annotation class ExperimentalDistributionDsl