Diagnostic messages
An index of the diagnostics produced by the Dart analyzer.
This page lists diagnostic messages produced by the Dart analyzer, with details about what those messages mean and how you can fix your code. For more information about the analyzer, see Customizing static analysis.
Diagnostic index
#The analyzer produces the following diagnostics for code that doesn't conform to the language specification or that might work in unexpected ways.
If a diagnostic has extra documentation and guidance, click Learn more to view it.
Classes extending 'AbiSpecificInteger' must have exactly one const constructor, no other members, and
no type parameters.
Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying
the mapping from ABI to a 'NativeType' integer with a fixed size.
Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying
the mapping from ABI to a 'NativeType' integer with a fixed size.
Invalid mapping to '{0}'; only mappings to 'Int8', 'Int16', 'Int32', 'Int64', 'Uint8', 'Uint16', 'UInt32',
and 'Uint64' are supported.
Members of classes can't be declared to be 'abstract'.
Fields can't be declared both 'abstract' and 'external'.
An 'abstract' class can't be declared as both 'final' and 'base'.
An 'abstract' class can't be declared as both 'final' and 'interface'.
Abstract fields cannot be late.
A 'sealed' class can't be marked 'abstract' because it's already implicitly abstract.
Static fields can't be declared 'abstract'.
Static methods can't be declared to be 'abstract'.
The '.address' expression can only be used as argument to a leaf native external call.
The receiver of '.address' must be a concrete 'TypedData', a concrete 'TypedData' '[]', an 'Array', an 'Array' '[]',
a Struct field, or a Union field.
A member named '{0}' is defined in '{1}' and '{2}', and neither is more specific.
A member named '{0}' is defined in {1}, and none are more specific.
The literal can't be either a map or a set because it contains at least one literal map entry or a spread
operator spreading a 'Map', and at least one element which is neither of these.
This literal must be either a map or a set, but the elements don't have enough information for type inference
to work.
Fields in a struct class whose type is 'Pointer' shouldn't have any annotations.
Type arguments can't have annotations because they aren't declarations.
Annotations can't have spaces or comments before the parenthesis.
An annotation can't use type arguments.
An annotation with type arguments must be followed by an argument list.
The argument type '{0}' can't be assigned to the parameter type '{1}'. {2}
The argument type '{0}' can't be assigned to the parameter type '{1} Function(Object)' or '{1} Function(Object, StackTrace)'.
A redirecting constructor can't have an 'assert' initializer.
The value of the 'assets' field is expected to be a list of relative file paths.
'{0}' is marked 'doNotStore' and shouldn't be assigned to a field or top-level variable.
The keywords 'await' and 'yield' can't be used as identifiers in an asynchronous or generator function.
The augmentation has an 'extends' clause, but an augmentation target already includes an 'extends' clause
and it isn't allowed to be repeated or changed.
The augmentation has the '{0}' modifier that the declaration doesn't have.
The augmentation is missing the '{0}' modifier that the declaration has.
Can't augment a {0} with a {1}.
The augmentation type parameter must have the same bound as the corresponding type parameter of the declaration.
The augmentation must have the same number of type parameters as the declaration.
The augmentation type parameter must have the same name as the corresponding type parameter of the declaration.
The declaration being augmented doesn't exist.
The augmented declaration is not a setter, it can't be used to write a value.
The augmented declaration is a setter, it can't be used to read a value.
The enclosing augmentation doesn't augment the operator '{0}'.
The 'await' expression can't be used in a 'late' local variable's initializer.
The await expression can only be used in an async function.
The 'await' expression can't be used for an expression with an extension type that is not a subtype of 'Future'.
Enums can't be declared to be 'base'.
Binary operator '{0}' is written as '{1}' instead of the written out word.
The body might complete normally, causing 'null' to be returned, but the return type, '{0}', is a potentially non-nullable type.
This 'onError' handler must return a value assignable to '{0}', but ends without returning a value.
This function has a nullable return type of '{0}', but ends without returning a value.
A break statement can't be used outside of a loop or switch statement.
The built-in identifier '{0}' can't be used as a prefix name.
The built-in identifier '{0}' can't be used as a type name.
The built-in identifier '{0}' can't be used as a type parameter name.
The built-in identifier '{0}' can't be used as a typedef name.
The built-in identifier '{0}' can't be used as an extension name.
The built-in identifier '{0}' can't be used as an extension type name.
Camera permissions make app incompatible for Chrome OS, consider adding optional features "android.hardware.camera"
and "android.hardware.camera.autofocus".
The last statement of the 'case' should be 'break', 'continue', 'rethrow', 'return', or 'throw'.
The switch case expression type '{0}' can't override the '==' operator.
The switch case expression type '{0}' must be a subtype of the switch expression type '{1}'.
This cast will always throw an exception because the nullable local variable '{0}' is not assigned.
This cast always throws an exception because the expression always evaluates to 'null'.
'catch' must be followed by '(identifier)' or '(identifier, identifier)'.
'catch' must be followed by '(identifier)' or '(identifier, identifier)'.
The class '{0}' doesn't have a constructor named '{1}'.
The instance member '{0}' can't be accessed on a class instantiation.
The static member '{0}' can't be accessed on a class instantiation.
Classes can't be declared inside other classes.
The class '{0}' can't be used as a mixin because it's neither a mixin class nor a mixin.
Constant values from a deferred library can't be used as keys in a 'const' map literal.
Constant values from a deferred library can't be used as values in a 'const' constructor.
Constant values from a deferred library can't be used as values in a 'const' list literal.
Constant values from a deferred library can't be used as values in a 'const' map literal.
Constant values from a deferred library can't be used as values in a 'const' set literal.
For-in loops use 'in' rather than a colon.
Concrete classes can't have 'Enum' as a superinterface.
'{0}' must have a method body because '{1}' isn't abstract.
'{0}' can't be used to name both a constructor and a static field in this class.
'{0}' can't be used to name both a constructor and a static getter in this class.
'{0}' can't be used to name both a constructor and a static method in this class.
'{0}' can't be used to name both a constructor and a static setter in this class.
Class '{0}' can't define field '{1}' and have method '{2}.{1}' with the same name.
The {0} '{1}' can't implement both '{2}' and '{3}' because the type arguments are different.
The {0} '{1}' can't inherit both a method and a setter named '{2}'.
Class '{0}' can't define method '{1}' and have field '{2}.{1}' with the same name.
Members can't be declared to be both '{0}' and '{1}'.
Class '{0}' can't define static member '{1}' and have instance member '{2}.{1}' with the same name.
'{0}' can't be used to name both a type parameter and the class in which the type parameter is defined.
'{0}' can't be used to name both a type parameter and the enum in which the type parameter is defined.
'{0}' can't be used to name both a type parameter and the extension in which the type parameter is defined.
'{0}' can't be used to name both a type parameter and the extension type in which the type parameter is defined.
'{0}' can't be used to name both a type parameter and the mixin in which the type parameter is defined.
'{0}' can't be used to name both a type parameter and a member in this class.
'{0}' can't be used to name both a type parameter and a member in this enum.
'{0}' can't be used to name both a type parameter and a member in this extension type.
'{0}' can't be used to name both a type parameter and a member in this extension.
'{0}' can't be used to name both a type parameter and a member in this mixin.
The matched value type '{0}' can never be equal to this constant of type '{1}'.
The expression of a constant pattern must be a valid constant.
Constructors can't have a return type.
A constructor invocation can't have type arguments after the constructor name.
Members can't be declared to be both 'const' and 'final'.
Classes can't be declared to be 'const'.
In a const constructor, a value of type '{0}' can't be assigned to the field '{1}', which has type '{2}'.
A value of type '{0}' can't be assigned to a parameter of type '{1}' in a const constructor.
Const constructors can't throw exceptions.
Const constructors can't have a body.
Can't define the 'const' constructor because the field '{0}' is initialized with a non-constant value.
This constructor can't be declared 'const' because a mixin adds the instance field: {0}.
This constructor can't be declared 'const' because the mixins add the instance fields: {0}.
A constant constructor can't call a non-constant super constructor of '{0}'.
Can't define a const constructor for a class with non-final fields.
The assertion in this constant expression failed.
An assertion failed with message '{0}'.
Extension methods can't be used in constant expressions.
Extension type methods can't be used in constant expressions.
Constant expressions don't support 'for' elements.
Methods can't be invoked in constant expressions.
In constant expressions, operands of the equality operator must have primitive equality.
The property '{0}' can't be accessed on the type '{1}' in a constant expression.
Evaluation of this constant expression throws an exception.
Evaluation of this constant expression throws an IntegerDivisionByZeroException.
In constant expressions, operands of this operator must be of type 'bool'.
In constant expressions, operands of this operator must be of type 'bool' or 'int'.
In constant expressions, operands of this operator must be of type 'bool', 'num', 'String' or 'null'.
In constant expressions, operands of this operator must be of type 'int'.
In constant expressions, operands of this operator must be of type 'num'.
In constant expressions, operands of this operator must be of type 'num' or 'String'.
In constant expressions, operands of this operator must be of type 'String'.
In constant expressions, operands of this operator must be of type 'Type'.
Only redirecting factory constructors can be declared to be 'const'.
Const variables must be initialized with a constant value.
Constant values from a deferred library can't be used to initialize a 'const' variable.
The type of a key in a constant map can't override the '==' operator, or 'hashCode', but the class '{0}' does.
Getters, setters and methods can't be declared to be 'const'.
An element in a constant set can't override the '==' operator, or 'hashCode', but the type '{0}' does.
Type parameters can't be used in a constant expression.
'const' can only be used together with a primary constructor declaration.
Arguments of a constant creation must be constant expressions.
A constant constructor tearoff can't use a type parameter as a type argument.
A constant creation can't use a type parameter as a type argument.
A constant function tearoff can't use a type parameter as a type argument.
The class '{0}' doesn't have a constant constructor '{1}'.
The class '{0}' doesn't have an unnamed constant constructor.
The label used in a 'continue' statement must be defined on either a loop or a switch member.
A continue statement can't be used outside of a loop or switch statement.
A continue statement in a switch statement must have a label as a target.
Couldn't infer type parameter '{0}'.{1}
Members can't be declared to be both 'covariant' and 'static'.
A constructor can't be declared to be 'covariant'.
Getters, setters and methods can't be declared to be 'covariant'.
Subclasses of 'Struct' and 'Union' are backed by native memory, and can't be instantiated by a generative constructor.
Dead code.
Dead code: The assigned-to wildcard variable is marked late and can never be referenced so this initializer
will never be evaluated.
Dead code: Catch clauses after a 'catch (e)' or an 'on Object catch (e)' are never reached.
Dead code: This on-catch block won't be executed because '{0}' is a subtype of '{1}' and hence will have
been caught already.
The left operand can't be null, so the right operand is never executed.
A switch expression may not use the
default keyword.The default 'List' constructor isn't available when null safety is enabled.
Default values aren't allowed in factory constructors that redirect to another constructor.
The deferred keyword should come immediately before the prefix ('as' clause).
The late local variable '{0}' is definitely unassigned at this point.
Using a colon as the separator before a default value is deprecated and will not be supported in language
version 3.0 and later.
Methods named 'factory' will become constructors when the primary_constructors feature is enabled.
The lint rule '{0}' is deprecated and replaced by '{1}'.
'{0}' is deprecated and shouldn't be used.
'{0}' is deprecated and shouldn't be used. {1}
Using the 'new' keyword in a comment reference is deprecated.
Extending 'Function' is deprecated.
Implementing 'Function' has no effect.
Mixing in 'Function' is deprecated.
Directives must appear before any declarations.
Only a generic type, generic function, generic instance method, or generic constructor can have type arguments.
The '{0}' argument must be formatted as {1}.
The '{0}' directive has '{1}' arguments, but only '{2}' are expected.
The '{0}' directive has an unexpected named argument, '{1}'.
The '{0}' directive is missing a '{1}' and a '{2}' argument.
The '{0}' directive is missing a '{1}' argument.
The '{0}' directive is missing a '{1}', a '{2}', and a '{3}' argument.
Doc directive is missing a closing curly brace ('}').
Doc directive is missing a closing tag.
Doc directive is missing an opening tag.
Doc directive '{0}' is unknown.
A dot shorthand can't be used where there is no context type.
The static getter '{0}' isn't defined for the context type '{1}'.
The static method or constructor '{0}' isn't defined for the context type '{1}'.
The modifier '{0}' was already specified.
The constructor with name '{0}' is already defined.
The unnamed constructor is already defined.
An import directive can only have one 'deferred' keyword.
The field '{0}' can't be initialized by multiple parameters in the same constructor.
The diagnostic '{0}' doesn't need to be ignored here because it's already being ignored.
The label '{0}' was already used in this switch statement.
The variable '{0}' is already assigned in this pattern.
An import directive can only have one prefix ('as' clause).
At most one rest element is allowed in a list or map pattern.
An enum must declare at least one constant name.
A record literal without fields can't have a trailing comma.
The list of named fields in a record type can't be empty.
Unable to decode bytes as UTF-8.
An enum value can't invoke a factory constructor.
The name of the enum value can't be the same as the enum's name.
The invoked constructor isn't a 'const' constructor.
The result of instantiating the enum to bounds is not well-bounded.
Enums can't be declared inside classes.
The enum must have at least one enum constant.
A comparison expression can't be an operand of another comparison expression.
A catch clause must have a body, even if it is empty.
A class declaration must have a body, even if it is empty.
A finally clause must have a body, even if it is empty.
A mixin declaration must have a body, even if it is empty.
A switch expression must have a body, even if it is empty.
A switch statement must have a body, even if it is empty.
A try statement must have a body, even if it is empty.
An extension declaration must have a body, even if it is empty.
An extension type declaration must have a body, even if it is empty.
Expected 'case' or 'default'.
Expected a class member.
Expected 'else' or comma.
Expected a method, getter, setter or operator declaration.
'{0}' can't be used as an identifier because it's a keyword.
Expected '{0}' instead of this.
Expected a list or map literal.
Expected a class name.
Expected a mixin name.
Expected the name of a class or mixin.
List patterns require one type argument or none, but {0} found.
List literals require one type argument or none, but {0} found.
Set literals require one type argument or none, but {0} were found.
Expected a representation field.
Expected a representation type.
Expected a string literal.
Expected to find '{0}'.
Map patterns require two type arguments or none, but {0} found.
Map literals require two type arguments or none, but {0} found.
Expected a type name.
'{0}' is experimental and could be removed or changed at any time.
This requires the '{0}' language feature to be enabled.
This requires the experimental '{0}' language feature to be enabled.
Export directives must precede part directives.
The symbol '{0}' is defined in a legacy library, and can't be re-exported from a library with null safety enabled.
Extension augmentations can't have 'on' clauses.
An extension can't define static member '{0}' and an instance member with the same name.
Extensions can't declare members with the same name as a member declared by 'Object'.
An extension override can't be used to access a static member from an extension.
The type of the argument to the extension override '{0}' isn't assignable to the extended type '{1}'.
An extension override can only be used to access instance members.
Extension overrides have no value so they can't be used as the receiver of a cascade expression.
Extension type constructors can't declare super formal parameters.
Extension type constructors can't include super initializers.
Extension types can't declare members with the same name as a member declared by 'Object'.
An extension type declaration can't have an 'extends' clause.
'{0}' is not a supertype of '{1}', the representation type.
'{0}', the representation type of '{1}', is not a supertype of '{2}', the representation type of '{3}'.
The extension type '{0}' has more than one distinct member named '{1}' from implemented types.
The extension type representation can't depend on itself.
An extension type declaration can't have a 'with' clause.
'{0}' must have a method body because '{1}' is an extension type.
Classes can't be declared to be 'external'.
An external constructor can't initialize fields.
An external constructor can't have any initializers.
Enums can't be declared to be 'external'.
A redirecting factory can't be external.
External factories can't have a body.
External getters can't have a body.
External fields cannot be late.
An external or native method can't have a body.
External operators can't have a body.
External setters can't have a body.
Typedefs can't be declared to be 'external'.
External fields can't have initializers.
External variables can't have initializers.
Can't have modifier '{0}' here.
Can't have modifier '{0}' in an extension type.
Can't have modifier '{0}' in a primary constructor.
Fields in a struct class must have exactly one annotation indicating the native type.
Too many positional arguments: {0} expected, but {1} found.
Factory constructors can't be named 'new'.
Top-level declarations can't be declared to be 'factory'.
A non-redirecting 'factory' constructor must have a body.
A 'factory' constructor can't have initializers.
There may be at most one @DefaultAsset annotation on a library.
Native functions and fields must have exactly one
@Native annotation.Only classes extending NativeFieldWrapperClass1 can be passed as Pointer.
Unexpected number of Native annotation parameters. Expected {0} but has {1}.
Unexpected number of Native annotation parameters. Expected {0} but has {1}. Native instance method annotation
must have receiver as first argument.
The field '{0}' can't be initialized twice in the same constructor.
Fields can't be initialized in the constructor if they are final and were already initialized at their declaration.
Fields can't be initialized in both the parameter list and the initializers.
A field can only be initialized in its declaring class
Initializing formal parameters can't be used in factory constructors.
Constructors in subclasses of 'Struct' and 'Union' can't have field initializers.
The initializer type '{0}' can't be assigned to the field type '{1}' in a const constructor.
The initializer type '{0}' can't be assigned to the field type '{1}'.
Field formal parameters can only be used in a constructor.
The redirecting constructor can't have a field initializer.
The parameter type '{0}' is incompatible with the field type '{1}'.
Fields in subclasses of 'Struct' and 'Union' can't have initializers.
Fields of 'Struct' and 'Union' subclasses must be marked external.
Members can't be declared to be both 'final' and 'covariant'.
Members marked 'late' with an initializer can't be declared to be both 'final' and 'covariant'.
Members can't be declared to be both 'final' and 'var'.
A constructor can't be declared to be 'final'.
Enums can't be declared to be 'final'.
'{0}' is final and was given a value when it was declared, so it can't be set to a new value.
Getters, setters and methods can't be declared to be 'final'.
A mixin can't be declared 'final'.
A mixin class can't be declared 'final'.
All final variables must be initialized, but '{0}' and '{1}' aren't.
All final variables must be initialized, but '{0}' isn't.
All final variables must be initialized, but '{0}', '{1}', and {2} others aren't.
{0}
The type '{0}' used in the 'for' loop must implement '{1}' with a type argument that can be assigned
to '{2}'.
Function-typed parameters can't specify 'const', 'final' or 'var' in place of a return type.
Generic function types can't be used as type parameter bounds.
A generic function type can't be a type argument.
A method tear-off on a receiver whose type is 'dynamic' can't have type arguments.
The class '{0}' can't extend 'Struct' or 'Union' because '{0}' is generic.
Constructors can't be a getter.
Getters can't be defined within methods or functions.
The return type of getter '{0}' is '{1}' which isn't assignable to the type '{2}' of its setter '{3}'.
The return type of getter '{0}' is '{1}' which isn't a subtype of the type '{2}' of its setter '{3}'.
Getters must be declared without a parameter list.
{0}
Constant values from a deferred library can't be used as values in an if condition inside a const collection literal.
Illegal assignment to non-assignable expression.
Functions marked 'async*' must have a return type that is a supertype of 'Stream' for some type 'T'.
Functions marked 'async' must have a return type which is a supertype of 'Future'.
Illegal character '{0}'.
A concrete instance member named '{0}' can't be declared in a class that implements 'Enum'.
A concrete instance member named '{0}' can't be inherited from '{1}' in a class that implements 'Enum'.
An instance member named 'values' can't be declared in a class that implements 'Enum'.
An instance member named 'values' can't be inherited from '{0}' in a class that implements 'Enum'.
The language version must be {0}.
A variable assigned by a pattern assignment can't be named '{0}'.
A pattern can't refer to an identifier named '{0}'.
The variable declared by a variable pattern can't be named '{0}'.
Functions marked 'sync*' must have a return type that is a supertype of 'Iterable' for some type 'T'.
The extends clause must be before the implements clause.
The on clause must be before the implements clause.
The with clause must be before the implements clause.
'{0}' can't be used in both the 'extends' and 'implements' clauses.
'{0}' can't be used in both the 'extends' and 'with' clauses.
The implicitly invoked unnamed constructor from '{0}' has required parameters.
The instance member '{0}' can't be accessed in an initializer.
The imported library defines a top-level function named 'loadLibrary' that is hidden by deferring this library.
Import directives must precede part directives.
The library '{0}' is legacy, and shouldn't be imported into a null safe library.
The URI '{0}' included in '{1}' can't be found when analyzing '{2}'.
The rule '{0}' is incompatible with '{1}'.
The rule '{0}' is incompatible with {1}, which is included from {2} file{3}.
The rule '{0}' is incompatible with {1}.
Case expressions must have the same types, '{0}' isn't a '{1}'.
'{0}' is inherited as a getter (from '{1}') and also a method (from '{2}').
Parts must have exactly the same language version override as the library.
The variable '{0}' has a different type and/or finality in this branch of the logical-or pattern.
The type argument(s) of the function '{0}' can't be inferred.
The type argument(s) of the generic function type '{0}' can't be inferred.
The type argument(s) of the constructor '{0}' can't be inferred.
The type of {0} can't be inferred without either a type or initializer.
The type of {0} can't be inferred; a type must be explicitly provided.
The loop variable in a for-each loop can't be initialized.
'{0}' is a static field in the enclosing class. Fields initialized in a constructor can't be static.
The static {0} '{1}' can't be accessed through an instance.
Instance members can't be accessed from a factory constructor.
Instance members can't be accessed from a static method.
Type aliases that expand to a type parameter can't be instantiated.
The integer literal is being used as a double, but can't be represented as a 64-bit double without overflow
or loss of precision: '{0}'.
Enums can't be declared to be 'interface'.
A mixin can't be declared 'interface'.
A mixin class can't be declared 'interface'.
Annotation must be either a const variable reference or const constructor invocation.
Constant values from a deferred library can't be used in annotations.
Constant values from a deferred library can't be used as annotations.
The keyword 'await' isn't allowed for a normal 'for' statement.
The annotation 'awaitNotRequired' can only be applied to a Future-returning function, or a Future-typed field.
The function '{0}' has type '{1}' that isn't of expected type '{2}'. This means its parameter or return
type doesn't match what is expected.
The function expression type '{0}' isn't of type '{1}'. This means its parameter or return type doesn't
match what is expected. Consider changing parameter type(s) or the returned type(s).
The literal '{0}' with type '{1}' isn't of expected type '{2}'.
The list literal type '{0}' isn't of expected type '{1}'. The list's type can be changed with an explicit
generic type argument or by changing the element types.
The map literal type '{0}' isn't of expected type '{1}'. The map's type can be changed with an explicit
generic type arguments or by changing the key and value types.
The set literal type '{0}' isn't of expected type '{1}'. The set's type can be changed with an explicit
generic type argument or by changing the element types.
The method tear-off '{0}' has type '{1}' that isn't of expected type '{2}'. This means its parameter
or return type doesn't match what is expected.
The constructor returns type '{0}' that isn't of expected type '{1}'.
The escape sequence '{0}' isn't a valid code point.
Comment references should contain a possibly prefixed identifier and can start with 'new', but shouldn't
contain anything else.
Invalid constant value.
The expression can't be prefixed by 'const' to form a constant pattern.
The binary operator {0} is not supported as a constant pattern.
Duplicate 'const' keyword in constant expression.
The empty record literal is not supported as a constant pattern.
This expression is not supported as a constant pattern.
Only negation of a numeric literal is supported as a constant pattern.
The unary operator {0} is not supported as a constant pattern.
The name of a constructor must match the name of the enclosing class.
The annotation '@Deprecated.extend' can only be applied to extendable classes.
The annotation '@Deprecated.implement' can only be applied to implementable classes.
The annotation '@Deprecated.instantiate' can only be applied to classes.
The annotation '@Deprecated.mixin' can only be applied to classes.
The annotation '@Deprecated.optional' can only be applied to optional parameters.
The annotation '@Deprecated.subclass' can only be applied to subclassable classes and mixins.
The method {0} can't have an exceptional return value (the second argument) when the return type of the
function is either 'void', 'Handle' or 'Pointer'.
The member '{0}' can't be exported as a part of a package's public API.
The member '{0}' can't be exported as a part of a package's public API, but is indirectly exported as
part of the signature of '{1}'.
Extension overrides must have exactly one argument: the value of 'this' in the extension method.
The name of a factory constructor must be the same as the name of the immediately enclosing class.
Record field names can't be a dollar sign followed by an integer when the integer is the index of a positional field.
Record field names can't be private.
Record field names can't be the same as a member from 'Object'.
Fields in struct classes can't have the type '{0}'. They can only be declared as 'int', 'double', 'Array', 'Pointer',
or subtype of 'Struct' or 'Union'.
Invalid generic function type.
An escape sequence starting with '\x' must be followed by 2 hexadecimal digits.
'{0}.{1}' ('{2}') isn't a valid concrete implementation of '{3}.{1}' ('{4}').
The setter '{0}.{1}' ('{2}') isn't a valid concrete implementation of '{3}.{1}' ('{4}').
Not a valid initializer.
Inline function types can't be used for parameters in a generic function type.
This pattern cannot appear inside a unary pattern (cast pattern, null check pattern, or null assert pattern)
without parentheses.
Only public elements in a package's private API can be annotated as being internal.
The Dart language version override comment can't be followed by any non-whitespace characters.
The Dart language version override comment must be specified with a version number, like '2.0', after the '=' character.
The Dart language version override comment must be specified with an '=' character.
The Dart language version override comment must be specified with exactly two slashes.
The Dart language version override comment must be specified with the word 'dart' in all lower case.
The Dart language version override number can't be prefixed with a letter.
The Dart language version override number must begin with '@dart'.
The language version override can't specify a version greater than the latest known language version: {0}.{1}.
The language version override must be specified before any declaration or directive.
The literal in a configuration can't contain interpolation.
The modifier '{0}' can't be applied to the body of a constructor.
The annotation '@nonVirtual' can only be applied to a concrete instance member.
The element can't be null, so the null-aware operator '?' is unnecessary.
The map entry key can't be null, so the null-aware operator '?' is unnecessary.
The map entry value can't be null, so the null-aware operator '?' is unnecessary.
The receiver can't be 'null' because of short-circuiting, so the null-aware operator '{0}' can't be used.
The receiver can't be null, so the null-aware operator '{0}' is unnecessary.
The string '{0}' isn't a user-definable operator.
The operator '{0}' can't be used with 'super'.
The operator '?.' cannot be used with 'super' because 'super' cannot be null.
'{0}.{1}' ('{2}') isn't a valid override of '{3}.{1}' ('{4}').
The setter '{0}.{1}' ('{2}') isn't a valid override of '{3}.{1}' ('{4}').
The member '{0}' is declared non-virtual in '{1}' and can't be overridden in subclasses.
The variable '{0}' doesn't have the same type and/or finality in all cases that share this body.
The variable '{0}' is available in some, but not all cases that share this body.
The variable '{0}' is not available because there is a label or 'default' case.
Generative enum constructors can only be used to create an enum constant.
Generative enum constructors can't be torn off.
The annotation '@reopen' can only be applied to a class that opens capabilities that the supertype intentionally disallows.
A value of type '{0}' can't be returned by the 'onError' handler because it must be assignable to '{1}'.
The return type '{0}' isn't assignable to '{1}', as required by 'Future.catchError'.
The modifier 'async*' isn't allowed for an expression function body.
Super parameters can only be used in non-redirecting generative constructors.
Can only use 'super' in an initializer for calling the superclass constructor (e.g. 'super()' or 'super.namedConstructor()')
The modifier 'sync' isn't allowed for an expression function body.
Can only use 'this' in an initializer for field initialization (e.g. 'this.x = something') and constructor
redirection (e.g. 'this()' or 'this.namedConstructor())
Constant list literals can't use a type parameter in a type argument, such as '{0}'.
Constant map literals can't use a type parameter in a type argument, such as '{0}'.
Constant set literals can't use a type parameter in a type argument, such as '{0}'.
The string '' can't stand alone.
An escape sequence starting with '\u{' must be followed by 1 to 6 hexadecimal digits followed by a '}'.
An escape sequence starting with '\u' must be followed by 4 hexadecimal digits.
An escape sequence starting with '\u' must be followed by 4 hexadecimal digits or from 1 to 6 digits
between '{' and '}'.
The 'covariant' keyword can only be used for parameters in instance methods or before non-final instance fields.
Uses of '{0}' should not be submitted to source control.
The identifier 'augmented' can only be used to reference the augmented declaration inside an augmentation.
An expression whose value is always 'null' can't be dereferenced.
The member '{0}' can only be used within instance members of subclasses of '{1}'.
The class '{0}' can't be extended outside of its library because it's a final class.
The class '{0}' can't be extended outside of its library because it's an interface class.
The class '{0}' can't be extended, implemented, or mixed in outside of its library because it's a sealed class.
The class '{0}' can't be implemented outside of its library because it's a base class.
The class '{0}' can't be implemented outside of its library because it's a final class.
The class '{0}' can't be used as a mixin superclass constraint outside of its library because it's a final class.
The mixin '{0}' can't be implemented outside of its library because it's a base mixin.
The member '{0}' can only be used for overriding.
The member '{0}' can only be used within '{1}' or a template library.
The member '{0}' can only be used within '{1}' or a test.
The member '{0}' is annotated with '{1}', but this annotation is only meaningful on declarations of public members.
The annotation 'visibleForOverriding' can only be applied to a public instance member that can be overridden.
The annotation 'visibleOutsideTemplate' can only be applied to a member of a class, enum, or mixin that
is annotated with 'visibleForTemplate'.
The '@Preview(...)' annotation can only be applied to public, statically accessible constructors and functions.
'@Preview(...)' can only accept arguments that consist of literals and public symbols.
The extension '{0}' doesn't define a 'call' method so the override can't be used in an invocation.
The expression doesn't evaluate to a function, so it can't be invoked.
Can't have a late final field in a class with a generative const constructor.
A pattern variable declaration may not use the
late keyword.The library directive must appear before all other directives.
The element type '{0}' can't be assigned to the list type '{1}'.
A {0} literal can't be prefixed by '{1}'.
A {0} literal can't be prefixed by 'new {1}'.
A literal can't be prefixed by 'new'.
Local function declarations can't specify any modifiers.
The type of the first positional parameter of the 'main' function must be a supertype of 'List'.
The function 'main' can't have any required named parameters.
The function 'main' can't have more than two required positional parameters.
The element type '{0}' can't be assigned to the map key type '{1}'.
The element type '{0}' can't be assigned to the map value type '{1}'.
A class member can't have the same name as the enclosing class.
The annotation doesn't match the declared type of the field.
Fields of type '{0}' in a subclass of '{1}' must have an annotation indicating the native type.
Missing selector such as '.identifier' or '[0]'.
Expected an assignment after the field name.
A try block must be followed by an 'on', 'catch', or 'finally' clause.
The closing parenthesis is missing.
Variables must be declared using the keywords 'const', 'final', 'var' or a type name.
Seeing this message constitutes a bug. Please report it.
Seeing this message constitutes a bug. Please report it.
Seeing this message constitutes a bug. Please report it.
The parameter '{0}' can't have a value of 'null' because of its type, but the implicit default value is 'null'.
With null safety, use the 'required' keyword, not the '@required' annotation.
Decimal digit expected.
An enum definition must have a body with at least one constant name.
The method {0} must have an exceptional return value (the second argument) when the return type of the
function is neither 'void', 'Handle', nor 'Pointer'.
Expected an expression after the assignment operator.
Missing expression after 'throw'.
Fields in struct classes must have an explicitly declared type of 'int', 'double' or 'Pointer'.
A function body must be provided.
Function types must have the keyword 'Function' before the parameter list.
Functions must have an explicit list of parameters.
Getters must have the keyword 'get' before the getter name.
Hexadecimal digit expected.
Expected an identifier.
Expected an initializer.
Operator declarations must be preceded by the keyword 'operator'.
Methods must have an explicit list of parameters.
The getter name is not specified explicitly, and the pattern is not a variable.
Named parameters in a function type must have a name
Library directives must include a library name.
Part-of directives must include a library name.
Missing a required override of '{0}' and '{1}'.
Missing a required override of '{0}', '{1}', and {2} more.
Missing a required override of '{0}'.
Deferred imports should have a prefix.
An extension type declaration must have a primary constructor declaration.
A primary constructor declaration must have formal parameters.
Expected quote (' or ").
The named parameter '{0}' is required, but there's no corresponding argument.
The parameter '{0}' is required.
The parameter '{0}' is required. {1}.
This function has a return type of '{0}', but doesn't end with a return statement.
Fields of type 'Array' must have exactly one 'Array' annotation.
The modifier 'sync' must be followed by a star ('*').
Expected a statement.
There is no '{0}' to close the parameter group.
Typedefs must have an explicit list of parameters.
A loop variable must be declared in a for-each loop before the 'in', but none was found.
Variable pattern '{0}' is missing in this branch of the logical-or pattern.
Can't have both positional and named parameters in a single parameter list.
The super-invoked member '{0}' has the type '{1}', and the concrete member in the class has the type '{2}'.
'{0}' can't be mixed onto '{1}' because '{1}' doesn't implement '{2}'.
The class doesn't have a concrete implementation of the super-invoked member '{0}'.
The class doesn't have a concrete implementation of the super-invoked setter '{0}'.
The class '{0}' can't be declared a mixin because it extends a class other than 'Object'.
The class '{0}' can't be used as a mixin because it declares a constructor.
Mixins can't declare constructors.
The class '{0}' can't be used as a mixin because it extends a class other than 'Object'.
The class '{0}' shouldn't be used as a mixin constraint because it is sealed, and any class mixing in
this mixin must have '{0}' as a superclass.
Deferred classes can't be used as superclass constraints.
Only classes and mixins can be used as superclass constraints.
A mixin can't have a with clause.
Mixin can only be applied to class.
The modifier '{0}' should be before the modifier '{1}'.
Each '{0}' definition can have at most one '{1}' clause.
Using multiple 'hide' or 'show' combinators is never necessary and often produces surprising results.
Each class definition can have at most one extends clause.
Each class or mixin definition can have at most one implements clause.
Only one library directive may be declared in a file.
Can't have multiple groups of named parameters in a single parameter list.
Each mixin definition can have at most one on clause.
Only one part-of directive may be declared in a file.
Multiple plugins can't be enabled.
Can't have multiple groups of positional parameters in a single parameter list.
Constructors can have only one 'this' redirection, at most.
Each extension type should have exactly one representation field.
A single loop variable must be declared in a for-each loop before the 'in', but {0} were found.
Each type parameter can have at most one variance modifier.
Each class definition can have at most one with clause.
The type '{0}' given to '{1}' must be a valid 'dart:ffi' native function type.
This class (or a class that this class inherits from) is marked as '@immutable', but one or more of its
instance fields aren't final: {0}
This method overrides a method annotated as '@mustCallSuper' in '{0}', but doesn't invoke the overridden method.
The return type of the function passed to 'NativeCallable.listener' must be 'void' rather than '{0}'.
Function expressions can't be named.
Function types can't be named.
Named parameters must be enclosed in curly braces ('{' and '}').
Native clause can only be used in the SDK and code that is loaded through native extensions.
Native clause in this form is deprecated.
'{0}' is an unsupported type for native fields. Native fields only support pointers, arrays or numeric
and compound types.
The native type of this field could not be inferred and must be specified in the annotation.
Native functions can only be declared in the SDK and code that is loaded through native extensions.
The native type of this function couldn't be inferred so it must be specified in the annotation.
The variable dimension of a variable-length array must be non-negative.
Constructors declared with the 'new' keyword can't be named 'new'.
Constructors declared with the 'new' keyword can't have qualified names.
The class '{0}' doesn't have a constructor named '{1}'.
The class '{0}' doesn't have an unnamed constructor.
Missing concrete implementation of '{0}'.
Missing concrete implementations of '{0}' and '{1}'.
Missing concrete implementations of '{0}', '{1}', '{2}', '{3}', and {4} more.
Missing concrete implementations of '{0}', '{1}', '{2}', and '{3}'.
Missing concrete implementations of '{0}', '{1}', and '{2}'.
Constant values from a deferred library can't be used as a case expression.
Constant values from a deferred library can't be used as a default parameter value.
The fields in a const record literal must be constants.
Constant values from a deferred library can't be used as fields in a 'const' record literal.
The relational pattern expression must be a constant.
The type arguments to '{0}' must be known at compile time, so they can't be type parameters.
Only a constructor can be declared to be a factory.
This instance creation must be 'const', because the {0} constructor is marked as '@literal'.
A non-constant map or set literal without type arguments can't be used as an expression statement.
An extension type parameter can't be used in a non-covariant position of its representation type.
The enum '{0}' isn't exhaustively matched by the switch cases because some of the enum constants are private.
The type '{0}' isn't exhaustively matched by the switch cases since it doesn't match the pattern '{1}'.
The enum '{0}' isn't exhaustively matched by the switch cases because some of the enum constants are private.
The type '{0}' isn't exhaustively matched by the switch cases since it doesn't match the pattern '{1}'.
The generative constructor '{0}' is expected, but a factory was found.
The unnamed constructor of superclass '{0}' (called by the default constructor of '{1}') must be a generative constructor,
but factory found.
The name of a library must be an identifier.
Can't invoke 'asFunction' because the function signature '{0}' for the pointer isn't a valid C function signature.
The part-of directive must be the only directive in a part.
Classes with primary constructors can't have non-redirecting generative constructors.
The
<activity> element should be allowed to be resized to allow users to take advantage
of the multi-window environment on Chrome OSThe type '{0}' isn't a valid type argument for '{1}'. The type argument must be a native integer, 'Float', 'Double', 'Pointer',
or subtype of 'Struct', 'Union', or 'AbiSpecificInteger'.
The URI must be a string literal.
The name '{0}' isn't a type, so it can't be used as a type argument.
The name '{0}' isn't a type and can't be used in an on-catch clause.
The operator '{0}' isn't user definable.
Normal parameters must occur before optional parameters.
The non-nullable local variable '{0}' must be assigned before it can be used.
1 positional argument expected by '{0}', but 0 found.
1 positional argument expected, but 0 found.
{0} positional arguments expected by '{1}', but {2} found.
{0} positional arguments expected, but {1} found.
Non-nullable instance field '{0}' must be initialized.
Type parameter bound types must be instantiated.
The Null-typed expression can't be used with a non-null-aware spread.
Can't infer missing types in '{0}' from overridden methods: {1}.
The superclass '{0}' doesn't have a zero argument constructor.
The class '{0}' can't extend '{1}' because '{1}' only has factory constructors (no generative constructors),
and '{0}' has at least one generative constructor.
The default "android.hardware.touchscreen" needs to be optional for Chrome OS.
A potentially nullable type can't be used in an 'on' clause because it isn't valid to throw a nullable expression.
A class, mixin, or extension type can't implement a nullable type.
'{0}' shouldn't be called with a 'null' argument for the non-nullable type argument '{1}'.
The '?..' cascade operator must be first in the cascade sequence.
This null-check will always throw an exception because the expression will always evaluate to 'null'.
The class 'Object' can't extend any other class.
Using a colon as the separator before a default value is no longer supported.
Optional parameters aren't allowed when defining an operator.
The '{0}' clause must come before the '{1}' clause.
The field doesn't override an inherited getter or setter.
The getter doesn't override an inherited getter.
The method doesn't override an inherited method.
The setter doesn't override an inherited setter.
The 'part of' directive can't use a name with the enhanced-parts feature.
The library is unnamed. A URI is expected, not a library name '{0}', in the part-of directive.
Variable '{0}' can't be declared in a pattern assignment.
Only local variables can be assigned in pattern assignments.
Constant values from a deferred library can't be used in patterns.
The matched value type '{0}' can never match the required type '{1}'.
The matched value of type '{0}' isn't assignable to the required type '{1}'.
Pattern variables can't be assigned inside the guard of the enclosing guarded pattern.
A pattern variable declaration may not appear outside a function or method.
Permission makes app incompatible for Chrome OS, consider adding optional {0} feature tag,
Plugins can only be specified in the root of a pub workspace or the root of a package that isn't in a workspace.
Positional arguments must occur before named arguments.
Positional parameters must be enclosed in square brackets ('[' and ']').
Positional super parameters can't be used when the super constructor invocation has a positional argument.
The prefix ('as' clause) should come before any show/hide combinators.
The name '{0}' is already used as an import prefix and can't be used to name a top-level element.
The name '{0}' refers to an import prefix, so it must be followed by '.'.
The prefix '{0}' can't be used here because it's shadowed by a local declaration.
The private name '{0}', defined by '{1}', conflicts with the same name defined by '{2}'.
Named parameters that don't refer to instance variables can't start with underscore.
The corresponding public name '{0}' is already the name of another parameter.
A private named parameter must be a public identifier after removing the leading underscore.
The setter '{0}' is private and can't be accessed outside the library that declares it.
The final variable '{0}' can't be read because it's potentially unassigned at this point.
The receiver is of type 'Never', and will never complete with a value.
A record literal with exactly one positional field requires a trailing comma.
A record type with exactly one positional field requires a trailing comma.
The constant constructor depends on itself.
Constructors can't redirect to themselves either directly or indirectly.
The URI '{0}' included in '{1}' includes '{1}', creating a circular reference.
'{0}' can't be a superinterface of itself: {1}.
'{0}' can't extend itself.
'{0}' can't implement itself.
'{0}' can't use itself as a mixin.
'{0}' can't use itself as a superclass constraint.
The {0} doesn't redeclare a {0} declared in a superinterface.
Redirecting constructors can't have a body.
Only factory constructor can specify '=' redirection.
The constructor '{0}' couldn't be found in '{1}'.
Generative constructors can't redirect to a factory constructor.
The redirecting constructor '{0}' can't redirect to a constructor of the abstract class '{1}'.
The redirected constructor '{0}' has incompatible parameters with '{1}'.
The return type '{0}' of the redirected constructor isn't a subtype of '{1}'.
The name '{0}' isn't a type and can't be used in a redirected constructor.
A constant redirecting constructor can't redirect to a non-constant constructor.
A redirecting constructor can't redirect to a type alias that expands to a type parameter.
Local variable '{0}' can't be referenced before it is declared.
Refutable patterns can't be used in an irrefutable context.
The constant expression type '{0}' is not assignable to the parameter type '{1}' of the '{2}' operator.
The return type of operators used in relational patterns must be assignable to 'bool'.
'{0}' was replaced by '{1}' in Dart '{2}'.
'{0}' was replaced by '{1}' in Dart '{2}'.
Representation fields can't have modifiers.
The representation field can't have a trailing comma.
Can't return a value from a generator function that uses the 'async*' or 'sync*' modifier.
'{0}' is annotated with 'doNotStore' and shouldn't be returned unless '{1}' is also annotated.
A value of type '{0}' can't be returned from the constructor '{1}' because it has a return type of '{2}'.
A value of type '{0}' can't be returned from the function '{1}' because it has a return type of '{2}'.
A value of type '{0}' can't be returned from the method '{1}' because it has a return type of '{2}'.
The returned type '{0}' isn't returnable from a '{1}' function, as required by the closure's context.
The class '{0}' wasn't exported from 'dart:core' until version 2.1, but this code is required to be able
to run on earlier versions.
The use of an as expression in a constant expression wasn't supported until version 2.3.2, but this code
is required to be able to run on earlier versions.
The use of the operator '{0}' for 'bool' operands in a constant context wasn't supported until version 2.3.2,
but this code is required to be able to run on earlier versions.
Tearing off a constructor requires the 'constructor-tearoffs' language feature.
Using the operator '==' for non-primitive types wasn't supported until version 2.3.2, but this code is
required to be able to run on earlier versions.
Extension methods weren't supported until version 2.6.0, but this code is required to be able to run
on earlier versions.
The operator '>>>' wasn't supported until version 2.14.0, but this code is required to be able
to run on earlier versions.
The use of an is expression in a constant context wasn't supported until version 2.3.2, but this code
is required to be able to run on earlier versions.
The type 'Never' wasn't supported until version 2.12.0, but this code is required to be able to run on
earlier versions.
Set literals weren't supported until version 2.2, but this code is required to be able to run on earlier versions.
This API is available since SDK {0}, but constraints '{1}' don't guarantee it.
The for, if, and spread elements weren't supported until version 2.3.0, but this code is required to
be able to run on earlier versions.
The if and spread elements weren't supported in constant expressions until version 2.5.0, but this code
is required to be able to run on earlier versions.
Enums can't be declared to be 'sealed'.
A mixin can't be declared 'sealed'.
A mixin class can't be declared 'sealed'.
Constructors can't be a setter.
Setters can't be defined within methods or functions.
The
<activity> element should not be locked to any orientation so that users can take
advantage of the multi-window environments and larger screens on Chrome OSThe element type '{0}' can't be assigned to the set type '{1}'.
The prefix of a deferred import can't be used in other import directives.
'Array's must have an 'Array' annotation that matches the dimensions.
Constant values from a deferred library can't be spread into a const literal.
The file has too many nested expressions or statements.
Instance member '{0}' can't be accessed using static access.
Constructors can't be static.
A 'static' getter must have a body.
Operators can't be static.
A 'static' setter must have a body.
The generic type '{0}' should have explicit type arguments but doesn't.
The mixin '{0}' must be 'base' because the supertype '{1}' is 'base'.
The mixin '{0}' must be 'base' because the supertype '{1}' is 'final'.
The type '{0}' must be 'base', 'final' or 'sealed' because the supertype '{1}' is 'base'.
The type '{0}' must be 'base', 'final' or 'sealed' because the supertype '{1}' is 'final'.
Classes and mixins can't implement deferred classes.
Classes can't extend deferred classes.
Classes can't mixin deferred classes.
'{0}' can't be used as a superclass constraint.
Classes and mixins can't implement '{0}'.
Classes can't extend '{0}'.
Classes can't mixin '{0}'.
The class '{0}' can't extend '{1}'.
The class '{0}' can't implement '{1}'.
The class '{0}' can't mix in '{1}'.
The class '{0}' shouldn't be extended, mixed in, or implemented because it's sealed.
The class '{0}' can't extend '{1}' because '{1}' is a subtype of 'Struct', 'Union', or 'AbiSpecificInteger'.
The class '{0}' can't implement '{1}' because '{1}' is a subtype of 'Struct', 'Union', or 'AbiSpecificInteger'.
The class '{0}' can't mix in '{1}' because '{1}' is a subtype of 'Struct', 'Union', or 'AbiSpecificInteger'.
A type alias that expands to a type parameter can't be implemented.
A type alias that expands to a type parameter can't be mixed in.
A type alias that expands to a type parameter can't be used as a superclass constraint.
A type alias that expands to a type parameter can't be used as a superclass.
The type '{0}' of this parameter isn't a subtype of the type '{1}' of the associated super constructor parameter.
No associated named super constructor parameter.
No associated positional super constructor parameter.
The class 'Object' can't invoke a constructor from a superclass.
The superconstructor call must be last in an initializer list: '{0}'.
The 'super' keyword can't be used in an extension because an extension doesn't have a superclass.
The 'super' keyword can't be used in an extension type because an extension type doesn't have a superclass.
The redirecting constructor can't have a 'super' initializer.
Type '{0}' of the switch expression isn't assignable to the type '{1}' of case expressions.
The default case should be the last case in a switch statement.
The 'default' case can only be declared once.
A generative constructor of an abstract class can't be torn off.
The Unicode code point 'U+{0}' changes the appearance of text from how it's interpreted by the compiler.
The Unicode code point 'U+{0}' changes the appearance of text from how it's interpreted by the compiler.
The type '{0}' of the thrown expression must be assignable to 'Object'.
{0}
The type of '{0}' can't be inferred because it depends on itself through the cycle: {1}.
Operators must be declared within a class.
Typedefs can't be declared inside classes.
Typedefs can't reference themselves directly or recursively via another typedef.
The deferred type '{0}' can't be used in a declaration, cast, or type test.
Can't use type arguments with type variable '{0}'.
'{0}' doesn't conform to the bound '{1}' of the type parameter '{2}'.
Factory constructors cannot have a return type.
Tests for non-null should be done with '!= null'.
Tests for null should be done with '== null'.
Constructors can't have type parameters.
Types parameters aren't allowed when defining an operator.
Static members can't reference type parameters of the class.
The name '{0}' isn't a type and can't be used in an 'is' expression.
The name '{0}' isn't defined, so it can't be used in an 'is' expression.
Unable to get content of '{0}'.
A nullable expression can't be used as a condition.
A nullable expression can't be used as an iterator in a for-in loop.
A nullable expression can't be used in a spread.
A nullable expression can't be used in a yield-each statement.
The function can't be unconditionally invoked because it can be 'null'.
The method '{0}' can't be unconditionally invoked because the receiver can be 'null'.
The operator '{0}' can't be unconditionally invoked because the receiver can be 'null'.
The property '{0}' can't be unconditionally accessed because the receiver can be 'null'.
The class '{0}' doesn't have a constructor named '{1}'.
The class '{0}' doesn't have an unnamed constructor.
The enum doesn't have a constructor named '{0}'.
The enum doesn't have an unnamed constructor.
The getter '{0}' isn't defined for the '{1}' function type.
The getter '{0}' isn't defined for the type '{1}'.
Undefined name 'await' in function body not marked with 'async'.
The method '{0}' isn't defined for the '{1}' function type.
The method '{0}' isn't defined for the type '{1}'.
The name '{0}' is being referenced through the prefix '{1}', but it isn't defined in any of the libraries
imported using that prefix.
The setter '{0}' isn't defined for the '{1}' function type.
The setter '{0}' isn't defined for the type '{1}'.
The getter '{0}' isn't defined in a superclass of '{1}'.
The method '{0}' isn't defined in a superclass of '{1}'.
The operator '{0}' isn't defined in a superclass of '{1}'.
The setter '{0}' isn't defined in a superclass of '{1}'.
{0}
A '$' has special meaning inside a string, and must be followed by an identifier or an expression in
curly braces ({}).
Digit separators ('_') in a number literal can only be placed between two digits.
There is no '{0}' to open a parameter group.
Unexpected text '{0}'.
Unexpected tokens.
The diagnostic '{0}' can't be ignored.
The dev dependency on {0} is unnecessary because there is also a normal dependency on that package.
The keyword 'final' isn't necessary because the parameter is implicitly 'final'.
The import of '{0}' is unnecessary because all of the used elements are also provided by the import of '{1}'.
A double can't equal 'double.nan', so the condition is always 'false'.
A double can't equal 'double.nan', so the condition is always 'true'.
The '!' will have no effect because the receiver can't be null.
The null-assert pattern will have no effect because the matched type isn't nullable.
The null-check pattern will have no effect because the matched type isn't nullable.
The operand can't be 'null', so the condition is always 'false'.
The operand can't be 'null', so the condition is always 'true'.
The operand must be 'null', so the condition is always 'false'.
The operand must be 'null', so the condition is always 'true'.
Unnecessary type check; the result is always 'false'.
Unnecessary type check; the result is always 'true'.
Static members from supertypes must be qualified by the name of the defining type.
Static members from the extended type or one of its superclasses must be qualified by the name of the
defining type.
The feature {0} isn't supported on Chrome OS, consider making it optional.
The feature {0} isn't supported on Chrome OS, consider making it optional.
The '{0}' operator is not supported.
Unterminated multi-line comment.
Unterminated string literal.
The exception variable '{0}' isn't used, so the 'catch' clause can be removed.
Dart native extensions are deprecated and aren't available in Dart 2.15.
Variable length 'Array's must only occur as the last field of Structs.
Variable patterns in declaration context can't specify 'var' or 'final' keyword.
A value of type '{0}' can't be assigned to a const variable of type '{1}'.
Variables can't be declared using both 'var' and a type name.
The keyword 'var' can't be used as a type name.
Classes can't be declared to be 'var'.
Enums can't be declared to be 'var'.
The return type can't be 'var'.
Typedefs can't be declared to be 'var'.
Type 'void' can't have type arguments.
The extends clause must be before the with clause.
The value of the 'workspace' field is required to be a list of relative file paths.
Workspace values must be a relative path of a subdirectory of '{0}'.
'{0}' is an '{1}' type parameter and can't be used in an '{2}' position in '{3}'.
Operator '-' should declare 0 or 1 parameter, but {0} found.
Operator '{0}' should declare exactly {1} parameters, but {2} found.
Setters must declare exactly one required positional parameter.
The type '{0}' is declared with {1} type parameters, but {2} type arguments were given.
The constructor '{0}.{1}' doesn't have type parameters.
The constructor '{0}.{1}` doesn't have type parameters.
The enum is declared with {0} type parameters, but {1} type arguments were given.
The extension '{0}' is declared with {1} type parameters, but {2} type arguments were given.
The function '{0}' is declared with {1} type parameters, but {2} type arguments were given.
This function is declared with {0} type parameters, but {1} type arguments were given.
The method '{0}' is declared with {1} type parameters, but {2} type arguments are given.
The default value of a positional parameter should be preceded by '='.
Expected '{0}' to close parameter group.
'{0}' can't be used contravariantly or invariantly in '{1}'.
The '{0}' type parameter '{1}' can't be used in an '{2}' position.
Yield statements must be in a generator function (one marked with either 'async*' or 'sync*').
Yield-each statements must be in a generator function (one marked with either 'async*' or 'sync*').
A yielded value of type '{0}' must be assignable to '{1}'.
The type '{0}' implied by the 'yield*' expression must be assignable to '{1}'.
The function '{0}' should have a return type but doesn't.
The method '{0}' should have a return type but doesn't.
toggle_on
Required named parameters should be before optional named parameters.
toggle_on
toggle_on
Missing type annotation.
toggle_on
Use 'package:' imports for files in the 'lib' directory.
toggle_on
Bad tracking annotation for this member.
There can be only one tracking annotation.
No required tracking annotation.
Part directives in the analyzer public API should point to files in the analyzer public API.
Element makes use of type(s) which is not part of the analyzer public API: {0}.
Element makes use of experimental type(s), but is not itself marked with
@experimental: {0}.Export directive exports element(s) that are not part of the analyzer public API: {0}.
Declarations in the analyzer public API should not end in "Impl".
The member '{0}' overrides an inherited member but isn't annotated with '@override'.
toggle_on
The member '{0}' is redeclaring but isn't annotated with '@redeclare'.
toggle_on
Unnecessary 'dynamic' type annotation.
toggle_on
toggle_on
Conditional expressions with a 'bool' literal can be simplified.
toggle_on
Catch clause should use 'on' to specify the type of exception being caught.
toggle_on
The type 'Error' should not be caught.
The type '{0}' should not be caught because it is a subclass of 'Error'.
toggle_on
Classes should define instance members.
toggle_on
Explicit check for double or int.
toggle_on
The method '{0}' should not be overridden in classes not annotated with '@immutable'.
toggle_on
Unnecessary escape of '{0}'.
toggle_on
Fields in 'const' classes should not have initializers.
toggle_on
Parameters should not be marked as 'final'.
toggle_on
Function literals shouldn't be passed to 'forEach'.
toggle_on
Classes that override '==' should not be implemented.
toggle_on
Integer literal can't be represented exactly when compiled to JavaScript.
toggle_on
Multiple variables declared on a single line.
toggle_on
Unnecessary null comparison in implementation of '=='.
toggle_on
'bool' parameters should be named parameters.
toggle_on
The typedef is unnecessary because it is only used in one place.
toggle_on
The value of the argument is redundant because it matches the default value.
toggle_on
Can't use a relative path to import a library in 'lib'.
toggle_on
The parameter name '{0}' doesn't match the name '{1}' in the overridden method.
toggle_on
toggle_on
toggle_on
Don't return 'null' from a function with a return type of 'void'.
Don't return 'null' from a method with a return type of 'void'.
toggle_on
Don't return 'this' from a method.
toggle_on
Setter has no corresponding getter.
toggle_on
The type parameter '{0}' shadows a type parameter from the enclosing {1}.
toggle_on
The parameter name '{0}' matches a visible type name.
The type parameter name '{0}' matches a visible type name.
toggle_on
Unnecessary type annotation on a function expression parameter.
toggle_on
toggle_on
The parameter '{0}' is not used in the constructor.
toggle_on
An 'async' function should have a 'Future' return type when it doesn't return a value.
toggle_on
Don't use web-only libraries outside Flutter web plugins.
toggle_on
Uses 'await' on an instance of '{0}', which is not a subtype of 'Future'.
toggle_on
The extension name '{0}' isn't an UpperCamelCase identifier.
toggle_on
Unnecessary duplication of receiver.
toggle_on
Don't cast a nullable value to a non-nullable type.
toggle_on
Sort combinator names alphabetically.
toggle_on
The referenced name isn't visible in scope.
toggle_on
The target of the conditional URI '{0}' doesn't exist.
toggle_on
The key '{0}' can't be used when '{1}' is also used.
The constant name '{0}' isn't a lowerCamelCase identifier.
toggle_on
Statements in {0} should be enclosed in a block.
toggle_on
The imported package '{0}' isn't a dependency of the importing package.
toggle_on
Constructors in a deprecated class should be deprecated.
Fields that are initialized by a deprecated parameter should be deprecated.
Parameters that initialize a deprecated field should be deprecated.
toggle_on
'{0}' is deprecated and shouldn't be used.
'{0}' is deprecated and shouldn't be used. {1}
toggle_on
The public property isn't described by either 'debugFillProperties' or 'debugDescribeChildren'.
toggle_on
Place 'dart:' {0} before other {0}.
Place 'package:' {0} before relative {0}.
Sort directive sections alphabetically.
Specify exports in a separate section after all imports.
toggle_on
'Future'-returning calls in a non-'async' function.
toggle_on
Invalid use of an environment declaration.
toggle_on
Missing documentation explaining why the diagnostic is ignored.
toggle_on
Empty constructor bodies should be written using a ';' rather than '{}'.
toggle_on
toggle_on
Missing a newline at the end of the file.
toggle_on
Unsafe use of 'DartType' in an 'is' check.
Missing case clauses for some constants in '{0}'.
toggle_on
Expected either an identifier or a string literal.
To-do comment doesn't follow the Flutter style.
toggle_on
Import of a library in the 'lib/src' directory of another package.
toggle_on
The {0} '{1}' reopens '{2}' because it is not marked '{3}'.
toggle_on
An element of kind '{0}' can't be replaced by an element of kind '{1}'.
This expression is not valid in a 'case' clause in Dart 3.0.
toggle_on
A change of type '{0}' can't be used for an element of kind '{1}'.
Invalid character '{0}'.
Keys must be of type 'String' but found the type '{0}'.
The parameter style must be one of the following: {0}.
The key 'requiredIf' can only be used with optional named parameters.
Cast from '{0}' to '{1}' casts a Dart value to a JS interop type, which might not be platform-consistent.
Cast from '{0}' to '{1}' casts a JS interop value to a Dart type, which might not be platform-consistent.
Cast from '{0}' to '{1}' casts a JS interop value to an incompatible JS interop type, which might not be platform-consistent.
Runtime check between '{0}' and '{1}' checks whether a Dart value is a JS interop type, which might not be platform-consistent.
Runtime check between '{0}' and '{1}' checks whether a JS interop value is a Dart type, which might not be platform-consistent.
Runtime check between '{0}' and '{1}' involves a non-trivial runtime check between two JS interop types that might not be platform-consistent.
Runtime check between '{0}' and '{1}' involves a runtime check between a JS interop value and an unrelated
JS interop type that will always be true and won't check the underlying type.
toggle_on
The value of '{0}' should be of type '{1}' but is of type '{2}'.
The value of '{0}' must be one of the following: '{1}'.
toggle_on
toggle_on
Assignment could be inlined in 'return' statement.
toggle_on
Missing a newline at the beginning of a multiline string.
toggle_on
The library name '{0}' isn't a lower_case_with_underscores identifier.
toggle_on
Invalid use of a private type in a public API.
toggle_on
The line length exceeds the 80-character limit.
toggle_on
toggle_on
The super parameter named '{0}'' does not share the same name as the corresponding parameter in the super constructor, '{1}'.
toggle_on
The code block is missing a specified language.
toggle_on
Missing the required key '{0}'.
Exactly one of the following keys must be provided: {0}.
Missing the end brace for the template.
Expected to find {0}.
At least one URI must be provided.
Missing whitespace between adjacent strings.
toggle_on
Invalid use of 'default' member in a switch.
toggle_on
The value of the case clause ('{0}') is equal to the value of an earlier case clause ('{1}').
toggle_on
The library prefix '{0}' starts with an underscore.
toggle_on
The local variable '{0}' starts with an underscore.
toggle_on
Unnecessary comparison to a boolean literal.
toggle_on
Using 'toString' on a 'Type' is not safe in production code.
toggle_on
The variable or property is being assigned to itself.
toggle_on
Don't commit soloed tests.
Don't create string literals with trailing spaces in tests.
The variable name '{0}' isn't a lowerCamelCase identifier.
toggle_on
The expression has no effect and can be removed.
toggle_on
The null check operator shouldn't be used on a variable whose type is a potentially nullable type parameter.
toggle_on
Closure can't be 'null' because it might be invoked.
toggle_on
Unnecessary type annotation on a local variable.
toggle_on
Omit the type annotation on a local variable when the type is obvious.
toggle_on
The type annotation isn't needed because it is obvious.
toggle_on
Unnecessary use of an abstract class.
toggle_on
Don't throw instances of classes that don't extend either 'Exception' or 'Error'.
toggle_on
Missing documentation for public API.
toggle_on
The package name '{0}' isn't a lower_case_with_underscores identifier.
toggle_on
The library name is not a dot-separated path prefixed by the package name.
toggle_on
Invalid assignment to the parameter '{0}'.
toggle_on
String literals shouldn't be concatenated by the '+' operator.
toggle_on
toggle_on
The 'if' statement could be replaced by a null-aware assignment.
toggle_on
Use 'const' with the constructor to improve performance.
toggle_on
Constructors in '@immutable' classes should be declared as 'const'.
toggle_on
Use 'const' for final variables initialized to a constant value.
toggle_on
Use 'const' literals as arguments to constructors of '@immutable' classes.
toggle_on
Always 'false' because 'indexOf' is always greater than or equal to -1.
Always 'true' because 'indexOf' is always greater than or equal to -1.
Unnecessary use of 'indexOf' to test for containment.
toggle_on
toggle_on
The pattern should be final.
The variable '{0}' should be final.
toggle_on
Use 'for' elements when building maps from iterables.
toggle_on
Use 'forEach' and a tear-off rather than a 'for' loop to apply a function to every element.
toggle_on
Use a function declaration rather than a variable assignment to bind a function to a name.
toggle_on
Use the generic function type syntax in 'typedef's.
toggle_on
Use an 'if' element to conditionally add elements.
toggle_on
Use the '??' operator rather than '?:' when testing for 'null'.
toggle_on
Use an initializing formal to assign a parameter to a field.
toggle_on
The addition of a list item could be inlined.
The addition of multiple list items could be inlined.
toggle_on
Unnecessary use of a 'double' literal.
toggle_on
Use interpolation to compose strings and values.
toggle_on
The comparison is always 'false' because the length is always greater than or equal to 0.
The comparison is always 'true' because the length is always greater than or equal to 0.
Use 'isEmpty' instead of 'length' to test whether the collection is empty.
Use 'isNotEmpty' instead of 'length' to test whether the collection is empty.
toggle_on
Use 'isNotEmpty' rather than negating the result of 'isEmpty'.
toggle_on
Use the 'is!' operator rather than negating the value of the 'is' operator.
toggle_on
Only mixins should be mixed in.
toggle_on
Use a null-aware invocation of the 'call' method rather than explicitly testing for 'null'.
toggle_on
Use the null-aware operator '?.' rather than an explicit 'null' comparison.
toggle_on
The addition of multiple elements could be inlined.
toggle_on
An uninitialized field should have an explicit type annotation.
An uninitialized variable should have an explicit type annotation.
toggle_on
Remove deprecated elements in breaking versions.
toggle_on
Missing a required trailing comma.
toggle_on
Use 'SizedBox.{0}' to avoid needing to specify the 'height' and 'width'.
toggle_on
The '{0}' argument should be last in widget constructor invocations.
toggle_on
Constructor declarations should be before non-constructor declarations.
toggle_on
Specify the type of a local variable when the type is non-obvious.
toggle_on
A type annotation is needed because it isn't obvious.
toggle_on
Missing type annotation.
toggle_on
toggle_on
Use a type annotation rather than 'assert' to enforce non-nullability.
toggle_on
Missing an 'await' for the 'Future' computed by this expression.
toggle_on
The variable '{0}' isn't defined.
Didn't expect to find {0}.
The accessor '{0}' is invalid.
Don't make a function 'async' if it doesn't use 'await'.
toggle_on
Unnecessary 'await'.
toggle_on
Unnecessary 'break' statement.
toggle_on
The diagnostic '{0}' isn't produced at this location so it doesn't need to be ignored.
The diagnostic '{0}' isn't produced in this file so it doesn't need to be ignored.
toggle_on
Library directives without comments or annotations should be avoided.
toggle_on
Unnecessary use of a null-aware operator to invoke an extension method on a nullable type.
toggle_on
Unreachable member '{0}' in an executable library.
toggle_on
The type of the operand ('{0}') isn't a subtype or a supertype of the value being matched ('{1}').
The type of the right operand ('{0}') isn't a subtype or a supertype of the left operand ('{1}').
toggle_on
Assigning to the attribute '{0}' is unsafe.
Invoking the constructor '{0}' is unsafe.
Invoking the method '{0}' is unsafe.
toggle_on
This type is unsafe: a type parameter occurs in a non-covariant position.
toggle_on
The key '{0}' isn't supported.
The key 'static' is only supported for elements in a class, enum, extension, or mixin.
Only version '1' is supported at this time.
Don't use 'BuildContext's across async gaps, guarded by an unrelated 'mounted' check.
Don't use 'BuildContext's across async gaps.
toggle_on
Use 'DecoratedBox' rather than a 'Container' with only a 'Decoration'.
toggle_on
Class should be an enum.
toggle_on
Instances of 'Color' should be created using an 8-digit hexadecimal integer (such as '0xFFFFFFFF').
toggle_on
Use the generic function type syntax to declare the parameter '{0}'.
toggle_on
Use an if-null operator to convert a 'null' to a 'bool'.
toggle_on
Use '{0}' rather than '% 2'.
toggle_on
Constructors for public widgets should have a named 'key' parameter.
toggle_on
Use 'late' for private members with a non-nullable type.
toggle_on
Use the constant '{0}' rather than a constructor returning the same object.
toggle_on
Use the null-aware marker '?' rather than a null check via an 'if'.
toggle_on
Parameter '{0}' could be a super parameter.
Parameters '{0}' could be super parameters.
toggle_on
Use the 'throwsA' matcher instead of using 'fail' when there is no exception thrown.
toggle_on
Start the name of the method with 'to' or 'as'.
toggle_on
Declare 'visit' methods for all registered node types.
Expected to find {0}, but found {1}.
Parse error: {0}
Was this page's content helpful?
Unless stated otherwise, the documentation on this site reflects Dart 3.10.3. Page last updated on 2025-9-15. View source or report an issue.