reasonmetadataparameterDefined3 alwaysThrowschecked
doNotStore doNotSubmit experimentalfactory immutableinternalisTest isTestGroupliteral mustBeConstmustBeOverridden
mustCallSuper
nonVirtualoptionalTypeArgs protected redeclarereopenrequiredsealed useResultvirtualvisibleForOverridingvisibleForTesting ImmutableRequiredResourceIdentifier UseResult
_AlwaysThrows_Checked _DoNotStore _DoNotSubmit
_Experimental_Factory _Internal_IsTest _IsTestGroup_Literal _MustBeConst_MustBeOverridden_MustCallSuper _NonVirtual_OptionalTypeArgs
_Protected
_Redeclare_Reopen_Sealed_Virtual_VisibleForOverriding_VisibleForTesting
deprecatedoverridemeta
DeprecatedStringboolintdoubleObjectnumTarget
TargetKind constructorfieldfunctiongettermethodtopLevelVariable classTypelibrary parametersetter
extensionType extension mixinType typedefType J["o|Q meta_meta.dart rb w M׀b<C
$%n:Y]iЅ߅ "m ;?և4gۉCDBuy:n+zʍiÍǎ Rݏ*zŏƐaޑ.|ΑݑBZ^=٭"QUayIݮ=CGiѯׯ߯,wŰְڱfZ56Ӵ QU $t}ȵ-.|ɷ EIQ
;<Fֺ%u$(r_Dpt Y @ @ @d @ A AG A A B
BZ B B B B C' CV CZ C C C D1 D D D D D E2 E E E F! Fr F F F F G GK G G H H HW H H I6 IW I[ I I I J JQ J J J J K0 Kz K K K K L" Lr L L M< M M M M N< Ng N N O O O] O O O O O P/ P3 Px P Q QK QO Q Q R$ Rt R R R S0 S S T T TV TZ T T U* Un U U U U V( V[ V V W W& WK WL W W W X X: X> X X X YB YC Y Y Y Z Z
Z[ Z Z [ [Q [ [ [ [ [ \ \' \t \ \ \ \ \ \ ]D ]H ]m ]q ] ] ^* ^U ^ ^ ^ _G _ _ _ _ _ ` `% `3 `@ `J `a `b ` ` ` ` a a aa ae a b bI b~ b b b b c9 c c c c c c d? d d d d e e) eJ el e e e e e e f f f4 fI f^ f} f f f g g g! gr g g h h
hP h h h i1 i i j j0 j6 jq jw j j k2 k4 k5 kK kd kf kg kx k k k k k k lF l] lr l l l l l l l l l m m m3 mK m` m m m m m m m m m m n n* n> n@ nA nS nh nj nk n n n n n n o! o; oP oh oj ok o o o o o o o p p p# p; p= p> pH p\ pq p p p p p p p p p q q q5 q8 qO qi qk ql q q q r
r r r r2 rJ rf r} r r r r r r s s sK sw s s s s s s s t t t t3 tI tK tL tV tn t t t t t t t t t t t u u u! u" ul u u u u u v+ vm v v v w w /// Annotations that developers can use to express the intentions that otherwise
/// can't be deduced by statically analyzing the source code.
///
/// 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.dev](https://pub.dev/packages/meta). To learn more
/// about using annotations, check out the
/// [Metadata](https://dart.dev/language/metadata) documentation. [e \G/// Used to annotate a class.
///
/// See [immutable] for more details. \j \ \C/// Initialize a newly created instance to have the given [reason]. \ \ \ \)` \J/// A human-readable explanation of the reason why the class is immutable. \ ^/// Used to annotate a named parameter `p` in a method or function `f`.
///
/// See [required] for more details.
///
/// **Deprecated:** This annotation is set to be deprecated and later
/// removed in a future release of `package:meta`.
/// In Dart 2.12 and later, use the built-in `required` keyword
/// to mark a named parameter as required.
/// To learn more about `required`, check out the documentation on
/// [named parameters](https://dart.dev/language/functions#named-parameters). `di ` `C/// Initialize a newly created instance to have the given [reason]. ` ` ` ^f `Y p p p p p> p? pE p pF p pJ pT pU p^ ph pi ps p} p~ p p p p q> qQ qW qe p p p q6 p q5 p p p p q q q
q q q" q, q- q, q q q r r r r r r r r r r r r r r& r' r4 r> r? rL rV rW rh rr rs r r r r r r r r r sw* s} s s s s t& t5 t; tE s s s t s t s s s s s t t
t t tLa t t t t tL tM tS t tT t tX tb tc tp tz t{ t$ t t t t tK u u
u u t t t t t u@ u u u u v: v v v v % #/// Used to annotate a function `f`. Indicates that `f` always throws an
/// exception. Any functions that override `f`, in class inheritance, are also
/// expected to conform to this contract.
///
/// Tools, such as the analyzer, can use this to understand whether a block of
/// code "exits". For example:
///
/// ```dart
/// @alwaysThrows toss() { throw 'Thrown'; }
///
/// int fn(bool b) {
/// if (b) {
/// return 0;
/// } else {
/// toss();
/// print("Hello.");
/// }
/// }
/// ```
///
/// Without the annotation on `toss`, it would look as though `fn` doesn't
/// always return a value. The annotation shows that `fn` does always exit. In
/// addition, the annotation reveals that any statements following a call to
/// `toss` (like the `print` call) are dead code.
///
/// Tools, such as the analyzer, can also expect this contract to be enforced;
/// that is, tools may emit warnings if a function with this annotation
/// _doesn't_ always throw.
///
/// **Deprecated:** This annotation is deprecated and will be
/// removed in a future release of `package:meta`.
/// After Dart 2.9, you can instead specify a return type of `Never`
/// to indicate that a function never returns.ۈ܈
2?@DM}/// Used to annotate a parameter of an instance method that overrides another
/// method.
///
/// Indicates that this parameter may have a tighter type than the parameter on
/// its superclass. The actual argument will be checked at runtime to ensure it
/// is a subtype of the overridden parameter type.
///
/// **Deprecated:** This annotation is deprecated and will be
/// removed in a future release of `package:meta`.
/// In Dart 2 and later, you can instead use the built-in `covariant` modifier.:;ElF//// Used to annotate a method, getter or top-level getter or function to
/// indicate that the value obtained by invoking it should not be stored in a
/// field or top-level variable. The annotation can also be applied to a class
/// to implicitly annotate all of the valid members of the class, or applied to
/// a library to annotate all of the valid members of the library, including
/// classes. If a value returned by an element marked as `doNotStore` is returned
/// from a function or getter, that function or getter should be similarly
/// annotated.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than a library, class,
/// method or getter, top-level getter or function, or
/// * an invocation of a member that has this annotation is returned by a method,
/// getter or function that is not similarly annotated as `doNotStore`, or
/// * an invocation of a member that has this annotation is assigned to a field
/// or top-level variable.ƅ/// Used to annotate a method, getter or top-level getter or function that is
/// not intended to be accessed in checked-in code, but might be ephemerally
/// used during development or local testing.
///
/// The intention of this annotation is to signify an API is available for
/// temporary or ephemeral use (such as debugging or local testing), but should
/// be removed before the code is submitted or merged into a tested branch of
/// the repository (e.g. `main` or similar).
///
/// For example:
///
/// ```dart
/// void test(
/// String name,
/// void Function() testFunction, {
/// @doNotSubmit bool skip = false,
/// }) { /* ... */ }
///
/// void main() {
/// // OK.
/// test('foo', () => print('foo'));
///
/// // HINT: Remove before submitting.
/// test('bar', () => print('bar'), skip: true);
/// }
/// ```
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * a declaration that has this annotation is referenced anywhere, including
/// the library in which it is declared, in checked-in code. Exceptions are
/// being referenced by a declaration that is also annotated with
/// `@doNotSubmit` _or_ referencing a parameter that is annotated with
/// `@doNotSubmit` in the same method or function.ʔ֔הۄs/// 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.
///
/// If the annotation is applied to a library then it is equivalent to applying
/// the annotation to all of the top-level members of the library. Applying the
/// annotation to a class does *not* apply the annotation to subclasses, but
/// does apply the annotation to members of the class.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with a declaration that is not part of the
/// public interface of a library (such as a local variable or a declaration
/// that is private) or a directive other than the first directive in the
/// library, or
/// * the declaration is referenced by a package that has not explicitly
/// indicated its intention to use experimental APIs (details TBD).4/// 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.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than a method, or
/// * a method that has this annotation can return anything other than a newly
/// allocated object or `null`.ƛǛ˂́/// Used to annotate a class `C`. Indicates that `C` and all subtypes of `C`
/// must be immutable.
///
/// A class is immutable if all of the instance fields of the class, whether
/// defined directly or inherited, are `final`.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than a class, or
/// * a class that has this annotation or extends, implements or mixes in a
/// class that has this annotation is not immutable.؝悟ox/// Used to annotate a declaration which should only be used from within the
/// package in which it is declared, and which should not be exposed from said
/// package's public API.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the declaration is declared in a package's public API, or is exposed from
/// a package's public API, or
/// * the declaration is private, an unnamed extension, a static member of a
/// private class, mixin, or extension, a value of a private enum, or a
/// constructor of a private class, or
/// * the declaration is referenced outside the package in which it is declared.zJ)/// Used to annotate a test framework function that runs a single test.
///
/// Tools, such as IDEs, can show invocations of such function in a file
/// structure view to help the user navigating in large test files.
///
/// The first parameter of the function must be the description of the test.ɡСѡՁ]-/// Used to annotate a test framework function that runs a group of tests.
///
/// Tools, such as IDEs, can show invocations of such function in a file
/// structure view to help the user navigating in large test files.
///
/// The first parameter of the function must be the description of the group.$015c?/// 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.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than a const constructor,
/// or
/// * an invocation of a constructor that has this annotation is not invoked
/// using the `const` keyword unless one or more of the arguments to the
/// constructor is not a compile-time constant.QІ/// Used to annotate a parameter which should be constant.
///
/// The Dart type system does not allow distinguishing values of constant
/// expressions from other values of the same type, so a function cannot
/// ask to have only constant values as arguments.
/// This annotation marks a parameter as requiring a constant expression as
/// argument. The analyzer can warn, or err if so configured, if a non-constant
/// expression is used as argument.
///
/// The annotation can be applied to any parameter, but if it is applied to a
/// parameter of an instance member, subclasses overriding the member will not
/// inherit the annotation. If the subclass member also wants a constant
/// argument, it must annotate its own parameter as well.
///
/// Notice that if an annotatated instance member overrides a superclass member
/// where the same parameter is not annotated with this annotation, then a user
/// can cast to the superclass and invoke with a non-constant argument without
/// any warnings.
///
/// An example use could be the arguments to functions annotated with
/// [ResourceIdentifier], as only constant arguments can be made available
/// to the post-compile steps.
///
/// ```dart
/// import 'package:meta/meta.dart' show mustBeConst;
///
/// void main() {
/// f();
/// A().i = 3;
/// }
///
/// const v = 3;
///
/// int f() => g(v);
///
/// int g(@mustBeConst int value) => value + 1;
///
/// class A {
/// int? _i;
///
/// int? get i => _i;
///
/// set i(@mustBeConst int? value) {
/// _i = value;
/// }
/// }
/// ```ޫD
/// Used to annotate an instance member `m` declared on a class or mixin `C`.
/// Indicates that every concrete subclass of `C` must directly override `m`.
///
/// The intention of this annotation is to "re-abtract" a member that was
/// previously concrete, and to ensure that subclasses provide their own
/// implementation of the member. For example:
///
/// ```dart
/// base class Entity {
/// @mustBeOverridden
/// String toString();
/// }
///
/// abstract class AbstractEntity extends Entity {
/// // OK: AbstractEntity is abstract.
/// }
///
/// sealed class SealedEntity extends Entity {
/// // OK: SealedEntity is sealed, which implies abstract.
/// }
///
/// mixin MixinEntity on Entity {
/// // OK: MixinEntity is abstract.
/// }
///
/// class Person extends Entity {
/// // ERROR: Missing new implementation of 'toString'.
/// }
///
/// class Animal extends Entity {
/// // OK: Animal provides its own implementation of 'toString'.
/// String toString() => 'Animal';
/// }
/// ```
///
/// This annotation places no restrictions on the overriding members. In
/// particular, it does not require that the overriding members invoke the
/// overridden member. The annotation [mustCallSuper] can be used to add that
/// requirement.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than an instance member
/// (a method, operator, field, getter, or setter) of a class or of a mixin,
/// or
/// * the annotation is associated with a member `m` in class or mixin `C`, and
/// there is a concrete class `D` which is a subclass of `C` (directly or
/// indirectly), and `D` does not directly declare a concrete override of `m`
/// and does not directly declare a concrete override of `noSuchMethod`. 126 /// Used to annotate an instance member (method, getter, setter, operator, or
/// field) `m`. Indicates that every invocation of a member that overrides `m`
/// must also invoke `m`. In addition, every method that overrides `m` is
/// implicitly annotated with this same annotation.
///
/// Note that private members with this annotation cannot be validly overridden
/// outside of the library that defines the annotated member.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than an instance member,
/// or
/// * a member that overrides a member that has this annotation can return
/// without invoking the overridden member.)*. /// Used to annotate an instance member (method, getter, setter, operator, or
/// field) `m` in a class `C` or mixin `M`. Indicates that `m` should not be
/// overridden in any classes that extend or mixin `C` or `M`.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with anything other than an instance member,
/// * the annotation is associated with an abstract member (because subclasses
/// are required to override the member),
/// * the annotation is associated with an extension method,
/// * the annotation is associated with a member `m` in class `C`, and there is
/// a class `D` or mixin `M`, that extends or mixes in `C`, that declares an
/// overriding member `m`.,78 Y? YCO [j
/// Used to annotate a declaration that was made public, so that it is more
/// visible than otherwise necessary, to make code testable.
///
/// Tools, such as the analyzer, can provide feedback if
///
/// * the annotation is associated with a declaration not in the `lib` folder
/// of a package, or a private declaration, or a declaration in an unnamed
/// static extension, or
/// * the declaration is referenced outside of its defining library or a
/// library which is in the `test` folder of the defining package. [~ [ [ meta M׀b<C
$%n:Y]iЅ߅ "m ;?և4gۉCDBuy:n+zʍiÍǎ Rݏ*zŏƐaޑ.|ΑݑBZ^=٭"QUayIݮ=CGiѯׯ߯,wŰְڱfZ56Ӵ QU $t}ȵ-.|ɷ EIQ
;<Fֺ%u$(r_Dpt Y @ @ @d @ A AG A A B
BZ B B B B C' CV CZ C C C D1 D D D D D E2 E E E F! Fr F F F F G GK G G H H HW H H I6 IW I[ I I I J JQ J J J J K0 Kz K K K K L" Lr L L M< M M M M N< Ng N N O O O] O O O O O P/ P3 Px P Q QK QO Q Q R$ Rt R R R S0 S S T T TV TZ T T U* Un U U U U V( V[ V V W W& WK WL W W W X X: X> X X X YB YC Y Y Y Z Z
Z[ Z Z [ [Q [ [ [ [ [ \ \' \t \ \ \ \ \ \ ]D ]H ]m ]q ] ] ^* ^U ^ ^ ^ _G _ _ _ _ _ ` `% `3 `@ `J `a `b ` ` ` ` a a aa ae a b bI b~ b b b b c9 c c c c c c d? d d d d e e) eJ el e e e e e e f f f4 fI f^ f} f f f g g g! gr g g h h
hP h h h i1 i i j j0 j6 jq jw j j k2 k4 k5 kK kd kf kg kx k k k k k k lF l] lr l l l l l l l l l m m m3 mK m` m m m m m m m m m m n n* n> n@ nA nS nh nj nk n n n n n n o! o; oP oh oj ok o o o o o o o p p p# p; p= p> pH p\ pq p p p p p p p p p q q q5 q8 qO qi qk ql q q q r
r r r r2 rJ rf r} r r r r r r s s sK sw s s s s s s s t t t t3 tI tK tL tV tn t t t t t t t t t t t u u u! u" ul u u u u u v+ vm v v v w w 3 alwaysThrowschecked
doNotStore doNotSubmit experimentalfactory immutableinternalisTest isTestGroupliteral mustBeConstmustBeOverridden
mustCallSuper
nonVirtualoptionalTypeArgs protected redeclarereopenrequiredsealed useResultvirtualvisibleForOverridingvisibleForTesting ImmutableRequiredResourceIdentifier UseResult
_AlwaysThrows_Checked _DoNotStore _DoNotSubmit
_Experimental_Factory _Internal_IsTest _IsTestGroup_Literal _MustBeConst_MustBeOverridden_MustCallSuper _NonVirtual_OptionalTypeArgs
_Protected
_Redeclare_Reopen_Sealed_Virtual_VisibleForOverriding_VisibleForTesting u