Information about an annotation.
The API of Annotation
instances.
An extractor class to create and pattern match with syntax Annotation(tpe, scalaArgs, javaArgs)
.
An array argument to a Java annotation as in @Target(value={TYPE,FIELD,METHOD,PARAMETER})
API of ArrayArgument
instances.
An extractor class to create and pattern match with syntax ArrayArgument(args)
where args
is the argument array.
A Java annotation argument
A literal argument to a Java annotation as "Use X instead"
in @Deprecated("Use X instead")
The API of LiteralArgument
instances.
An extractor class to create and pattern match with syntax LiteralArgument(value)
where value
is the constant argument.
A nested annotation argument to a Java annotation as @Nested
in @Outer(@Nested)
.
API of NestedArgument
instances.
An extractor class to create and pattern match with syntax NestedArgument(annotation)
where annotation
is the nested annotation.
The constructor/extractor for Annotation
instances.
The constructor/extractor for ArrayArgument
instances.
The constructor/extractor for LiteralArgument
instances.
The constructor/extractor for NestedArgument
instances.
Returns string formatted according to given format
string.
Returns string formatted according to given format
string.
Format strings are as for String.format
(@see java.lang.String.format).
The methods available for each reflection entity, without the implementation. Since the reflection entities are later overridden by runtime reflection and macros, their API counterparts guarantee a minimum set of methods that are implemented.
Extractors provide the machinery necessary to allow pattern matching and construction of reflection entities that is similar to case classes, although the entities are only abstract types that are later overridden.
EXPERIMENTAL
This trait provides annotation support for the reflection API.
The API distinguishes between two kinds of annotations:
When a Scala annotation that inherits from scala.annotation.StaticAnnotation or scala.annotation.ClassfileAnnotation is compiled, it is stored as special attributes in the corresponding classfile, and not as a Java annotation. Note that subclassing just scala.annotation.Annotation is not enough to have the corresponding metadata persisted for runtime reflection.
The distinction between Java and Scala annotations is manifested in the contract of scala.reflect.api.Annotations#Annotation, which exposes both
scalaArgs
andjavaArgs
. For Scala or Java annotations extending scala.annotation.ClassfileAnnotationscalaArgs
is empty and arguments are stored injavaArgs
. For all other Scala annotations, arguments are stored inscalaArgs
andjavaArgs
is empty.Arguments in
scalaArgs
are represented as typed trees. Note that these trees are not transformed by any phases following the type-checker. Arguments injavaArgs
are repesented as a map from scala.reflect.api.Names#Name to scala.reflect.api.Annotations#JavaArgument. Instances ofJavaArgument
represent different kinds of Java annotation arguments:For more information about
Annotation
s, see the Reflection Guide: Annotations, Names, Scopes, and More