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

Introduce RequiresOptIn and OptIn annotations

Browse Source 
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
This commit is contained in:
Alexander Udalov
2019-12-13 21:11:48 +03:00
parent 33bc3db144
commit cdbabf224f
17 changed files with 119 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+8 -8
View File
@@ -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)");
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalMarkerDeclarationAnnotationChecker.kt
+5 -3
View File
@@ -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<ArrayValue>()?.value.orEmpty()
checkUseExperimentalUsage(annotationClasses, trace, entry)
}
ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAME -> {
in ExperimentalUsageChecker.EXPERIMENTAL_FQ_NAMES -> {
isAnnotatedWithExperimental = true
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt
+22 -14
View File
@@ -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
}
}
idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideMemberChooserObject.kt
+3 -1
View File
@@ -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
idea/src/org/jetbrains/kotlin/idea/quickfix/ExperimentalFixesFactory.kt
+3 -3
View File
@@ -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
}
}
}
idea/src/org/jetbrains/kotlin/idea/quickfix/MakeModuleExperimentalFix.kt
+3 -3
View File
@@ -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)
}
}
}
}
idea/src/org/jetbrains/kotlin/idea/quickfix/expectactual/ExpectActualUtils.kt
+7 -3
View File
@@ -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<Kt
classes = newExistingClasses
}
}
}
libraries/stdlib/js/src/kotlin/annotations.kt
+1
View File
@@ -171,6 +171,7 @@ public annotation class JsQualifier(val value: String)
* or with the `-Xuse-experimental=kotlin.js.ExperimentalJsExport` compiler option is given.
*/
@Experimental(level = Experimental.Level.WARNING)
@RequiresOptIn(level = RequiresOptIn.Level.WARNING)
@SinceKotlin("1.3")
public annotation class ExperimentalJsExport
libraries/stdlib/src/kotlin/annotations/ExperimentalStdlibApi.kt
+1
View File
@@ -15,6 +15,7 @@ import kotlin.annotation.AnnotationTarget.*
* or by using the compiler argument `-Xuse-experimental=kotlin.ExperimentalStdlibApi`.
*/
@Experimental(level = Experimental.Level.ERROR)
@RequiresOptIn(level = RequiresOptIn.Level.ERROR)
@Retention(AnnotationRetention.BINARY)
@Target(
CLASS,
libraries/stdlib/src/kotlin/annotations/Multiplatform.kt
+1
View File
@@ -17,6 +17,7 @@ import kotlin.internal.RequireKotlinVersionKind
* or by using the compiler argument `-Xuse-experimental=kotlin.ExperimentalMultiplatform`.
*/
@Experimental
@RequiresOptIn
@MustBeDocumented
@Target(
CLASS,
libraries/stdlib/src/kotlin/annotations/OptIn.kt
+55
View File
@@ -0,0 +1,55 @@
/*
* Copyright 2010-2018 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 kotlin
import kotlin.annotation.AnnotationRetention.BINARY
import kotlin.annotation.AnnotationRetention.SOURCE
import kotlin.annotation.AnnotationTarget.*
import kotlin.internal.RequireKotlin
import kotlin.internal.RequireKotlinVersionKind
import kotlin.reflect.KClass
/**
* Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.
*
* Call sites of any declaration annotated with that marker should opt-in to the API either by using [OptIn],
* or by being annotated with that marker themselves, effectively causing further propagation of the opt-in requirement.
*
* This class requires opt-in itself and can only be used with the compiler argument `-Xopt-in=kotlin.RequiresOptIn`.
*/
@Target(ANNOTATION_CLASS)
@Retention(BINARY)
@SinceKotlin("1.3")
@RequireKotlin("1.3.70", versionKind = RequireKotlinVersionKind.COMPILER_VERSION)
public annotation class RequiresOptIn(val level: Level = Level.ERROR) {
/**
* Severity of the diagnostic that should be reported on usages which did not explicitly opted into
* the API either by using [OptIn] or by being annotated with the corresponding marker annotation.
*/
public enum class Level {
/** Specifies that a warning should be reported on incorrect usages of this API. */
WARNING,
/** Specifies that an error should be reported on incorrect usages of this API. */
ERROR,
}
}
/**
* Allows to use the API denoted by the given markers in the annotated file, declaration, or expression.
* If a declaration is annotated with [OptIn], its usages are **not** required to opt-in to that API.
*
* This class requires opt-in itself and can only be used with the compiler argument `-Xopt-in=kotlin.RequiresOptIn`.
*/
@Target(
CLASS, PROPERTY, LOCAL_VARIABLE, VALUE_PARAMETER, CONSTRUCTOR, FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, EXPRESSION, FILE, TYPEALIAS
)
@Retention(SOURCE)
@SinceKotlin("1.3")
@RequireKotlin("1.3.70", versionKind = RequireKotlinVersionKind.COMPILER_VERSION)
public annotation class OptIn(
vararg val markerClass: KClass<out Annotation>
)
libraries/stdlib/src/kotlin/contracts/ContractBuilder.kt
+2 -1
View File
@@ -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) { }
public inline fun contract(builder: ContractBuilder.() -> Unit) { }
libraries/stdlib/src/kotlin/experimental/inferenceMarker.kt
+1
View File
@@ -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)
libraries/stdlib/src/kotlin/time/ExperimentalTime.kt
+2 -1
View File
@@ -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
public annotation class ExperimentalTime
libraries/stdlib/unsigned/src/kotlin/annotations/Unsigned.kt
+1
View File
@@ -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)
libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDceDsl.kt
+2 -1
View File
@@ -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
annotation class ExperimentalDceDsl
libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/dsl/ExperimentalDistributionDsl.kt
+2 -1
View File
@@ -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
annotation class ExperimentalDistributionDsl