Annotation

Returns a KClass instance corresponding to the annotation type of this annotation.

Makes the annotated annotation class an associated object key.

Allows to infer generic type arguments of a function from the calls in the annotated function parameter of that function.

Makes top level function available from C/C++ code with the given name.

Marks the annotated declaration as deprecated.

When applied to annotation class X specifies that X defines a DSL language

Signals that the annotated annotation class is a marker of an experimental API.

The experimental marker for associated objects API.

This marker distinguishes the experimental contract declaration API and is used to opt-in for that feature when declaring contracts of user functions.

Marks experimental JS export annotations.

The experimental multiplatform support API marker.

This annotation marks the standard library API that is considered experimental and is not subject to the general compatibility guarantees given for the standard library: the behavior of such API may be changed or the API may be removed completely in any further release.

This annotation marks the experimental preview of the standard library API for measuring time and working with durations.

The experimental marker for type inference augmenting annotations.

Marks the API that is dependent on the experimental unsigned types, including those types themselves.

Makes Kotlin subclass of Objective-C class visible for runtime lookup after Kotlin main function gets invoked.

Signifies that the annotated functional type represents an extension function.

Exports top-level declaration.

Denotes an external declaration that must be imported from native JavaScript library.

Gives a declaration (a function, a property or a class) specific name in JavaScript.

Denotes an external declaration that can be used without module system.

Adds prefix to external declarations in a source file.

Specifies that a JVM default method should be generated for non-abstract Kotlin interface member.

Instructs the Kotlin compiler not to generate getters/setters for this property and expose it as a field.

Instructs the Kotlin compiler to generate a multifile class with top-level functions and properties declared in this file as one of its parts. Name of the corresponding multifile class is provided by the JvmName annotation.

Specifies the name for the Java class or method which is generated from this element.

Instructs the Kotlin compiler to generate overloads for this function that substitute default parameter values.

Specifies that an additional static method needs to be generated from this element if it's a function. If this element is a property, additional static getter/setter methods should be generated.

Instructs compiler to generate or omit wildcards for type arguments corresponding to parameters with declaration-site variance, for example such as Collection<out T> has.

Sets ACC_SYNTHETIC flag on the annotated target in the Java bytecode.

Instructs compiler to generate wildcard for annotated type arguments corresponding to parameters with declaration-site variance.

This annotation is present on any class file produced by the Kotlin compiler and is read by the compiler and reflection. Parameters have very short JVM names on purpose: these names appear in all generated class files, and we'd like to reduce their size.

This meta-annotation determines that an annotation is a part of public API and therefore should be included in the generated documentation for the element to which the annotation is applied.

Makes Kotlin method in Objective-C class accessible through Objective-C dispatch to be used as action sent by control in UIKit or AppKit.

Makes Kotlin property in Objective-C class settable through Objective-C dispatch to be used as IB outlet.

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.

Marks an expected annotation class that it isn't required to have actual counterparts in all platforms.

Annotates type arguments of functional type and holds corresponding parameter name specified by the user in type declaration (if any).

When applied to a class or a member with internal visibility allows to use it from public inline functions and makes it effectively public.

Instructs the Kotlin compiler to treat annotated Java class as pure implementation of given Kotlin interface. "Pure" means here that each type parameter of class becomes non-platform type argument of that interface.

This meta-annotation determines that an annotation is applicable twice or more on a single code element

Specifies a code fragment that can be used to replace a deprecated function, property or class. Tools such as IDEs can automatically apply the replacements specified through this annotation.

Signals that the annotated annotation class is a marker of an API that requires an explicit opt-in.

Classes and interfaces marked with this annotation are restricted when used as receivers for extension suspend functions. These suspend extensions can only invoke other member or extension suspend functions on this particular receiver and are restricted from calling arbitrary suspension functions.

Classes and interfaces marked with this annotation are restricted when used as receivers for extension suspend functions. These suspend extensions can only invoke other member or extension suspend functions on this particular receiver only and are restricted from calling arbitrary suspension functions.

Preserve the function entry point during global optimizations.

Preserve the function entry point during global optimizations, only for the given target.

This meta-annotation determines whether an annotation is stored in binary output and visible for reflection. By default, both are true.

Marks a top level variable with a backing field or an object as immutable. It is possible to share such object between multiple threads, but it becomes deeply frozen, so no changes can be made to its state or the state of objects it refers to.

Specifies the first version of Kotlin where a declaration has appeared. Using the declaration and specifying an older API version (via the -api-version command line option) will result in an error.

Marks the JVM method generated from the annotated function as strictfp, meaning that the precision of floating point operations performed inside the method needs to be restricted in order to achieve better portability.

Suppresses the given compilation warnings in the annotated element.

Forces the compiler to use specified symbol name for the target external function.

Marks the JVM method generated from the annotated function as synchronized, meaning that the method will be protected from concurrent execution by multiple threads by the monitor of the instance (or, for static methods, the class) on which the method is defined.

This meta-annotation indicates the kinds of code elements which are possible targets of an annotation.

Marks a top level variable with a backing field or an object as thread local. The object remains mutable and it is possible to change its state, but every thread will have a distinct copy of this object, so changes in one thread are not reflected in another.

This annotation indicates what exceptions should be declared by a function when compiled to a JVM method.

This annotation indicates what exceptions should be declared by a function when compiled to a platform method.

Marks the JVM backing field of the annotated property as transient, meaning that it is not part of the default serialized form of the object.

Suppresses errors about variance conflict

Allows to use experimental API denoted by the given markers in the annotated file, declaration, or expression. If a declaration is annotated with UseExperimental, its usages are not required to opt-in to that experimental API.

Marks the JVM backing field of the annotated property as volatile, meaning that writes to this field are immediately made visible to other threads.