Diagnostic messages
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.
The option '{0}' is no longer supported.
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.
Null-aware property access can't be used in a constant expression.
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.
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.
The identifier 'augmented' has a special meaning inside augmenting declarations.
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.
'{0}' is a deprecated lint rule and should not be used.
'{0}' is deprecated and should be replaced by '{1}'.
'{0}' is deprecated and shouldn't be used.
'{0}' is deprecated and shouldn't be used. {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.
Doc imports can't be deferred.
Doc imports can't have show or hide combinators.
Doc imports can't have configurations.
Doc imports can't have prefixes.
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 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.
The rule {0} is already specified and doesn't need to be specified again.
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.
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.
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'.
External constructors can't have a body.
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.
Fields can't be declared to be 'external'.
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.
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.
Initializing formal parameters can only be used in constructors.
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.
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.
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
Functions marked 'async' must have a return type which is a supertype of 'Future'.
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
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.
{3} in {0}({1}..{2})
Warning in the included options file {0}({1}..{2}): {3}
The include file '{0}' in '{1}' can't be found when analyzing '{2}'.
The rule '{0}' is incompatible with the rule '{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 '{0}' can't be inferred.
The type argument(s) of the function '{0}' can't be inferred.
The return type of '{0}' cannot 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 {1} '{0}' 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 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.
'{1}.{0}' ('{2}') isn't a valid concrete implementation of '{3}.{0}' ('{4}').
The setter '{1}.{0}' ('{2}') isn't a valid concrete implementation of '{3}.{0}' ('{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.
Invalid option specified for '{0}': {1}
'{1}.{0}' ('{2}') isn't a valid override of '{3}.{0}' ('{4}').
The setter '{1}.{0}' ('{2}') isn't a valid override of '{3}.{0}' ('{4}').
The member '{0}' is declared non-virtual in '{1}' and can't be overridden in subclasses.
Generative enum constructors can only be used as targets of redirection.
The annotation '@reopen' can only be applied to a class that opens capabilities that the supertype intentionally disallows.
The type parameter '{0}' is annotated with @required but only named parameters without a default value can be annotated with it.
Incorrect use of the annotation @required on the optional positional parameter '{0}'. Optional positional parameters cannot be required.
Redundant use of the annotation @required on the required positional parameter '{0}'.
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'.
Invalid format for the '{0}' section.
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.
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.
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 concrete implementation of '{0}'.
Missing concrete implementations of '{0}' and '{1}'.
Missing concrete implementations of '{0}', '{1}', and {2} more.
Deferred imports should have a prefix.
An extension type declaration must have a primary constructor declaration.
A primary constructor declaration must have formal parameters.
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.
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 type '{0}' is not exhaustively matched by the switch cases since it doesn't match '{1}'.
The type '{0}' is not exhaustively matched by the switch cases since it doesn't match '{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 parameter type of '==' operators should be non-nullable.
The part-of directive must be the only directive in a part.
The <activity> element should be allowed to be resized to allow users to take advantage of the multi-window environment on Chrome OS
The type '{1}' isn't a valid type argument for '{0}'. 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 '{2}', but {1} 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.
{0}
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,
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}'.
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 include file '{0}' in '{1}' includes itself recursively.
'{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 removed in Dart '{1}'
'{0}' was removed in Dart '{1}'
'{0}' was replaced by '{2}' in Dart '{1}'.
'{0}' was replaced by '{2}' in Dart '{1}'.
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 '{2}' because it has a return type of '{1}'.
A value of type '{0}' can't be returned from the function '{2}' because it has a return type of '{1}'.
A value of type '{0}' can't be returned from the method '{2}' because it has a return type of '{1}'.
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 OS
The element type '{0}' can't be assigned to the set type '{1}'.
'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'.
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 '{2}' of the type parameter '{1}'.
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.
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'.
'{0}' is not a recognized lint rule.
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}'.
There is no '{0}' to open a parameter group.
Unexpected text '{0}'.
Unexpected tokens.
The diagnostic '{0}' can't be ignored.
Unnecessary cast pattern.
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'.
Unnecessary wildcard pattern.
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.
'{0}' isn't a recognized error code.
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 option '{1}' isn't supported by '{0}'.
The option '{1}' isn't supported by '{0}'. Try using the only supported option: '{2}'.
The option '{1}' isn't supported by '{0}'.
The value '{1}' isn't supported by '{0}'.
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 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.
Required named parameters should be before optional named parameters.
Missing type annotation.
Use 'package:' imports for files in the 'lib' directory.
The member '{0}' overrides an inherited member but isn't annotated with '@override'.
The member '{0}' is redeclaring but isn't annotated with '@redeclare'.
Unnecessary 'dynamic' type annotation.
Conditional expressions with a 'bool' literal can be simplified.
Catch clause should use 'on' to specify the type of exception being caught.
The type 'Error' should not be caught.
The type '{0}' should not be caught because it is a subclass of 'Error'.
Classes should define instance members.
Explicit check for double or int.
The method '{0}' should not be overridden in classes not annotated with '@immutable'.
Unnecessary escape of '{0}'.
Fields in 'const' classes should not have initializers.
Parameters should not be marked as 'final'.
Function literals shouldn't be passed to 'forEach'.
Classes that override '==' should not be implemented.
Integer literal can't be represented exactly when compiled to JavaScript.
Multiple variables declared on a single line.
Unnecessary null comparison in implementation of '=='.
'bool' parameters should be named parameters.
The typedef is unnecessary because it is only used in one place.
The value of the argument is redundant because it matches the default value.
Can't use a relative path to import a library in 'lib'.
The parameter name '{0}' doesn't match the name '{1}' in the overridden method.
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'.
Don't return 'this' from a method.
Setter has no corresponding getter.
The type parameter '{0}' shadows a type parameter from the enclosing {1}.
The parameter name '{0}' matches a visible type name.
The type parameter name '{0}' matches a visible type name.
Unnecessary type annotation on a function expression parameter.
The parameter '{0}' is not used in the constructor.
An 'async' function should have a 'Future' return type when it doesn't return a value.
Don't use web-only libraries outside Flutter web plugins.
Uses 'await' on an instance of '{0}', which is not a subtype of 'Future'.
The extension name '{0}' isn't an UpperCamelCase identifier.
Unnecessary duplication of receiver.
Don't cast a nullable value to a non-nullable type.
Sort combinator names alphabetically.
The referenced name isn't visible in scope.
The target of the conditional URI '{0}' doesn't exist.
The constant name '{0}' isn't a lowerCamelCase identifier.
Statements in {0} should be enclosed in a block.
The imported package '{0}' isn't a dependency of the importing package.
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.
'{0}' is deprecated and shouldn't be used.
'{0}' is deprecated and shouldn't be used. {1}
The public property isn't described by either 'debugFillProperties' or 'debugDescribeChildren'.
Place 'dart:' {0}s before other {0}s.
Place 'package:' {0}s before relative {0}s.
Sort directive sections alphabetically.
Specify exports in a separate section after all imports.
'Future'-returning calls in a non-'async' function.
Invalid use of an environment declaration.
Missing documentation explaining why the diagnostic is ignored.
Empty constructor bodies should be written using a ';' rather than '{}'.
Missing a newline at the end of the file.
Unsafe use of 'DartType' in an 'is' check.
Missing case clauses for some constants in '{0}'.
To-do comment doesn't follow the Flutter style.
Import of a library in the 'lib/src' directory of another package.
The {0} '{1}' reopens '{2}' because it is not marked '{3}'.
This expression is not valid in a 'case' clause in Dart 3.0.
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.
Assignment could be inlined in 'return' statement.
Missing a newline at the beginning of a multiline string.
The library name '{0}' isn't a lower_case_with_underscores identifier.
Invalid use of a private type in a public API.
The line length exceeds the 80-character limit.
The super parameter named '{0}'' does not share the same name as the corresponding parameter in the super constructor, '{1}'.
The code block is missing a specified language.
Missing whitespace between adjacent strings.
Invalid use of 'default' member in a switch.
The value of the case clause ('{0}') is equal to the value of an earlier case clause ('{1}').
The library prefix '{0}' starts with an underscore.
The local variable '{0}' starts with an underscore.
Unnecessary comparison to a boolean literal.
Using 'toString' on a 'Type' is not safe in production code.
The variable or property is being assigned to itself.
The variable name '{0}' isn't a lowerCamelCase identifier.
The expression has no effect and can be removed.
The null check operator shouldn't be used on a variable whose type is a potentially nullable type parameter.
Closure can't be 'null' because it might be invoked.
Unnecessary type annotation on a local variable.
Omit the type annotation on a local variable when the type is obvious.
The type annotation isn't needed because it is obvious.
Unnecessary use of an abstract class.
Don't throw instances of classes that don't extend either 'Exception' or 'Error'.
Missing documentation for public API.
The package name '{0}' isn't a lower_case_with_underscores identifier.
The library name is not a dot-separated path prefixed by the package name.
Invalid assignment to the parameter '{0}'.
String literals shouldn't be concatenated by the '+' operator.
The 'if' statement could be replaced by a null-aware assignment.
Use 'const' with the constructor to improve performance.
Constructors in '@immutable' classes should be declared as 'const'.
Use 'const' for final variables initialized to a constant value.
Use 'const' literals as arguments to constructors of '@immutable' classes.
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.
The pattern should be final.
The variable '{0}' should be final.
Use 'for' elements when building maps from iterables.
Use 'forEach' and a tear-off rather than a 'for' loop to apply a function to every element.
Use a function declaration rather than a variable assignment to bind a function to a name.
Use the generic function type syntax in 'typedef's.
Use an 'if' element to conditionally add elements.
Use the '??' operator rather than '?:' when testing for 'null'.
Use an initializing formal to assign a parameter to a field.
The addition of a list item could be inlined.
The addition of multiple list items could be inlined.
Unnecessary use of a 'double' literal.
Use interpolation to compose strings and values.
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.
Use 'isNotEmpty' rather than negating the result of 'isEmpty'.
Use the 'is!' operator rather than negating the value of the 'is' operator.
Only mixins should be mixed in.
Use a null-aware invocation of the 'call' method rather than explicitly testing for 'null'.
Use the null-aware operator '?.' rather than an explicit 'null' comparison.
The addition of multiple elements could be inlined.
An uninitialized field should have an explicit type annotation.
An uninitialized variable should have an explicit type annotation.
Missing a required trailing comma.
Use 'SizedBox.{0}' to avoid needing to specify the 'height' and 'width'.
The '{0}' argument should be last in widget constructor invocations.
Constructor declarations should be before non-constructor declarations.
Specify the type of a local variable when the type is non-obvious.
A type annotation is needed because it isn't obvious.
Missing type annotation.
Use a type annotation rather than 'assert' to enforce non-nullability.
Missing an 'await' for the 'Future' computed by this expression.
Don't make a function 'async' if it doesn't use 'await'.
Unnecessary 'await'.
Unnecessary 'break' statement.
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.
Library directives without comments or annotations should be avoided.
Unnecessary use of a null-aware operator to invoke an extension method on a nullable type.
Unnecessary use of 'unawaited'.
Unreachable member '{0}' in an executable library.
Assigning to the attribute '{0}' is unsafe.
Invoking the constructor '{0}' is unsafe.
Invoking the method '{0}' is unsafe.
This type is unsafe: a type parameter occurs in a non-covariant position.
Don't use 'BuildContext's across async gaps, guarded by an unrelated 'mounted' check.
Don't use 'BuildContext's across async gaps.
Use 'DecoratedBox' rather than a 'Container' with only a 'Decoration'.
Class should be an enum.
Instances of 'Color' should be created using an 8-digit hexadecimal integer (such as '0xFFFFFFFF').
Use the generic function type syntax to declare the parameter '{0}'.
Use an if-null operator to convert a 'null' to a 'bool'.
Use '{0}' rather than '% 2'.
Constructors for public widgets should have a named 'key' parameter.
Use 'late' for private members with a non-nullable type.
Use the constant '{0}' rather than a constructor returning the same object.
Use the null-aware marker '?' rather than a null check via an 'if'.
Parameter '{0}' could be a super parameter.
Parameters '{0}' could be super parameters.
Use the 'throwsA' matcher instead of using 'fail' when there is no exception thrown.
Start the name of the method with 'to' or 'as'.
Unless stated otherwise, the documentation on this site reflects Dart 3.7.3. Page last updated on 2025-05-08. View source or report an issue.