Constants for use in metadata annotations.

See also @deprecated and @override in the dart:core library.

Annotations provide semantic information that tools can use to provide a better user experience. For example, an IDE might not autocomplete the name of a function that's been marked @deprecated, or it might display the function's name differently.

For information on installing and importing this library, see the meta package on pub.dartlang.org (http://pub.dartlang.org/packages/meta). For examples of using annotations, see Metadata in the language tour.

Classes

Immutable
Used to annotate a class. [...]
Required
Used to annotate a named parameter p in a method or function f. [...]

Constants

alwaysThrows → _AlwaysThrows
Used to annotate a function f. Indicates that f always throws an exception. Any functions that override f, in class inheritence, are also expected to conform to this contract. [...]
const _AlwaysThrows()
checked → _Checked
Used to annotate a parameter of an instance method that overrides another method. [...]
const _Checked()
experimental → _Experimental
Used to annotate a library, or any declaration that is part of the public interface of a library (such as top-level members, class members, and function parameters) to indicate that the annotated API is experimental and may be removed or changed at any-time without updating the version of the containing package, despite the fact that it would otherwise be a breaking change. [...]
const _Experimental()
factory → _Factory
Used to annotate an instance or static method m. Indicates that m must either be abstract or must return a newly allocated object or null. In addition, every method that either implements or overrides m is implicitly annotated with this same annotation. [...]
const _Factory()
immutable Immutable
Used to annotate a class C. Indicates that C and all subtypes of C must be immutable. [...]
const Immutable()
literal → _Literal
Used to annotate a const constructor c. Indicates that any invocation of the constructor must use the keyword const unless one or more of the arguments to the constructor is not a compile-time constant. [...]
const _Literal()
mustCallSuper → _MustCallSuper
Used to annotate an instance method m. Indicates that every invocation of a method that overrides m must also invoke m. In addition, every method that overrides m is implicitly annotated with this same annotation. [...]
const _MustCallSuper()
optionalTypeArgs → _OptionalTypeArgs
Used to annotate a class declaration C. Indicates that any type arguments declared on C are to be treated as optional. Tools such as the analyzer and linter can use this information to suppress warnings that would otherwise require type arguments to be provided for instances of C.
const _OptionalTypeArgs()
protected → _Protected
Used to annotate an instance member (method, getter, setter, operator, or field) m in a class C. If the annotation is on a field it applies to the getter, and setter if appropriate, that are induced by the field. Indicates that m should only be invoked from instance methods of C or classes that extend, implement or mix in C, either directly or indirectly. Additionally indicates that m should only be invoked on this, whether explicitly or implicitly. [...]
const _Protected()
required Required
Used to annotate a named parameter p in a method or function f. Indicates that every invocation of f must include an argument corresponding to p, despite the fact that p would otherwise be an optional parameter. [...]
const Required()
virtual → _Virtual
Used to annotate a field that is allowed to be overridden in Strong Mode.
const _Virtual()
visibleForOverriding → _VisibleForOverriding
Used to annotate an instance member that was made public so that it could be overridden but that is not intended to be referenced from outside the defining library. [...]
const _VisibleForOverriding()
visibleForTesting → _VisibleForTesting
Used to annotate a declaration was made public, so that it is more visible than otherwise necessary, to make code testable. [...]
const _VisibleForTesting()