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.
Constructors on abstract classes can't be torn off.
The class '{0}' is abstract and can't be instantiated.
Members of classes can't be declared to be 'abstract'.
Extension fields can't be declared 'abstract'.
Fields can't be declared both 'abstract' and 'external'.
Abstract fields cannot have initializers.
Abstract fields can't have initializers.
Abstract fields cannot have initializers.
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.
Abstract methods can't use 'async', 'async*', or 'sync*'.
Factory redirects to class '{0}', which is abstract and can't be instantiated.
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.
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
This is one of the extension members.
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 method '{0}' is defined in multiple extensions for '{1}' and neither is more specific.
The operator '{0}' is defined in multiple extensions for '{1}' and neither is more specific.
The property '{0}' is defined in multiple extensions for '{1}' and neither is 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.
'{0}' can't implement both '{1}' and '{2}'
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
A type variable on a function type can't have annotations.
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.
Can't break to a target in a different function.
Can't continue at a target in a different function.
An anonymous method with a parameter list must have exactly one required, positional parameter.
The argument type '{0}' can't be assigned to the parameter type '{1}'.
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)'.
The control character {0} can only be used in strings and comments.
assert can't be used as an expression.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}'.
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
'await' can't be used as an identifier in 'async', 'async*', or 'sync*' methods.
The asynchronous for-in can only be used in functions marked with 'async' or 'async*'.
await expressions are not supported in late local initializers.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.
'await' can only be used in 'async' or 'async*' methods.
The 'await' expression can't be used for an expression with an extension type that is not a subtype of 'Future'.
The 'await' expression can't be used for an expression with an extension type that is not a subtype of 'Future'.
Uses 'await' on an instance of '{0}', which is not a subtype of 'Future'.
toggle_on
The class '{0}' can't be implemented outside of its library because it's a base class.
Enums can't be declared to be 'base'.
The mixin '{0}' can't be implemented outside of its library because it's a base mixin.
The type '{0}' is a subtype of '{1}', and '{1}' is defined here.
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.
Generic type '{0}' can't be used without type arguments in the bounds of its own type variables. It is
referenced indirectly through '{1}'.
Generic type '{0}' can't be used without type arguments in the bounds of its own type variables.
Generic type '{0}' can't be used without type arguments in a type variable bound.
A break statement can't be used outside of a loop or switch statement.
Can't break to '{0}' in a different function.
Can't use '{0}' as a name here.
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.
The extension name '{0}' isn't an UpperCamelCase identifier.
toggle_on
Camera permissions make app incompatible for Chrome OS, consider adding optional features "android.hardware.camera"
and "android.hardware.camera.autofocus".
Found this candidate, but the arguments don't match.
The class '{0}' has a constructor that takes no arguments.
Can't assign to the const variable '{0}'.
Can't assign to 'this'.
Can't assign to the final variable '{0}'.
Can't assign to a parenthesized expression.
Can't assign to super.
Can't assign to a type literal.
Unable to read the 'libraries.json' specification file:
{0}.
Both Iterable and Map spread elements encountered in ambiguous literal.
Not enough type information to disambiguate between literal set and literal map.
'{0}' can't be declared with named parameters.
'{0}' can't be declared with optional parameters.
Can't infer a packages file when compiling multiple inputs.
Can't infer a packages file from an input 'package:*' URI.
Can't infer a return type for '{0}' as the overridden members don't have a combined signature.
Can't infer the type of '{0}': circularity found during type inference.
Can't infer a type for '{0}' as the overridden members don't have a combined signature.
Can't infer types for '{0}' as the overridden members don't have a combined signature.
Error when reading '{0}': {1}
The class '{0}' can't be used as a mixin because it isn't a mixin class nor a mixin.
'{0}' is not supported in constant expressions.
'{0}' can't be used in a constant expression because it's marked as 'deferred' which means it isn't available
until loaded.
A prefix can't be used as an expression.
A prefix can't be used with null-aware operators.
Unnecessary duplication of receiver.
toggle_on
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 always throws an exception because the expression always evaluates to 'null'.
This cast will always throw an exception because the nullable local variable '{0}' is not assigned.
Don't cast a nullable value to a non-nullable type.
toggle_on
'catch' must be followed by '(identifier)' or '(identifier, identifier)'.
'catch' must be followed by '(identifier)' or '(identifier, identifier)'.
Classes and mixins can't implement deferred classes.
Classes can't be declared inside other classes.
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.
Cannot use class '{0}' in a dynamic module.
Cannot extend, implement or mix-in class '{0}' in a dynamic module.
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.
Sort combinator names alphabetically.
toggle_on
Class '{0}' inherits multiple members named '{1}' with incompatible signatures.
The referenced name isn't visible in scope.
toggle_on
Concrete classes can't have 'Enum' as a superinterface.
'{0}' must have a method body because '{1}' isn't abstract.
The target of the conditional URI '{0}' doesn't exist.
toggle_on
'{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}'.
The key '{0}' can't be used when '{1}' is also used.
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.
Conflicts with the implicit setter of the field '{0}'.
Field '{0}' with the implicit setter.
Conflicts with type variable '{0}'.
This is the type variable.
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}'.
This constructor is const.
Can't have a late final field in a class with a const constructor.
Constructor is marked 'const' so all fields must be final.
Field isn't final, but constructor is 'const'.
A value of type '{0}' can't be assigned to a parameter of type '{1}' in a const constructor.
A constant constructor can't call a non-constant constructor.
Const constructors can't throw exceptions.
A const constructor can't have a body.
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}'.
A constant constructor can't call a non-constant super constructor.
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}'.
Case expression '{0}' does not have a primitive operator '=='.
Constant expression depends on itself.
While analyzing:
'{0}' can't be used in a constant expression because it's marked as 'deferred' which means it isn't available
until loaded.
The element '{0}' conflicts with another existing element in the set.
The key '{0}' conflicts with another existing key in the map.
The element '{0}' does not have a primitive operator '=='.
The element '{0}' does not have a primitive equality.
Binary operator '==' requires receiver constant '{0}' of a type with primitive equality or type 'double',
but was of type '{1}'.
Error evaluating constant expression: {0}
Extension operations can't be used in constant expressions.
Extension methods can't be used in constant expressions.
Extension type methods can't be used in constant expressions.
External constructors can't be evaluated in constant expressions.
External factory constructors can't be evaluated in constant expressions.
This assertion failed.
This assertion failed with message: {0}
This assertion failed with a non-String message.
Constant expressions don't support 'for' elements.
Variable get not found: '{0}'
Binary operator '{0}' on '{1}' requires operand of type '{2}', but was of type '{3}'.
Binary operator '==' requires receiver constant '{0}' of type 'Null', 'bool', 'int', 'double', or 'String',
but was of type '{1}'.
The method '{0}' can't be invoked on '{1}' in a constant expression.
The property '{0}' can't be accessed on '{1}' in a constant expression.
The property '{0}' can't be accessed on '{1}' in a constant expression.
The property '{0}' can't be accessed on '{1}' in a constant expression.
The invocation of '{0}' is not allowed in a constant expression.
The constant value '{0}' can't be used as part of a string interpolation in a constant expression.
Only values of type 'null', 'bool', 'int', 'double', or 'String' can be used.
The symbol name must be a valid public Dart member name, public constructor name, or library name, optionally qualified,
but was '{0}'.
Expected constant '{0}' to be of type '{1}', but was of type '{2}'.
The key '{0}' does not have a primitive operator '=='.
The key '{0}' does not have a primitive equality.
Methods can't be invoked in constant expressions.
Binary operator '{0}' on '{1}' requires non-negative operand, but was '{2}'.
The variable '{0}' is not a constant, only constant expressions are allowed.
Constant expression must be non-null.
Only lists and sets can be used in spreads in constant lists and sets.
Only maps can be used in spreads in constant maps.
Null value during constant evaluation.
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.
Constant evaluation error:
Evaluation of this constant expression throws an exception.
Evaluation of this constant expression throws an IntegerDivisionByZeroException.
Binary operator '{0} ~/ {1}' results is Infinity or NaN.
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'.
Couldn't evaluate constant expression.
Unhandled core exception: {0}
Unhandled exception: {0}
Binary operator '{0}' on '{1}' requires non-zero divisor, but divisor was '0'.
Only redirecting factory constructors can be declared to be 'const'.
Constant factory constructor can't delegate to a non-constant constructor.
The const variable '{0}' must be initialized.
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.
'const' can only be used together with a primary constructor declaration.
The constant name '{0}' isn't a lowerCamelCase identifier.
toggle_on
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.
The constructor conflicts with member '{0}'.
Conflicting member '{0}'.
Redirecting constructors can't be cyclic.
'{0}' was already initialized by this constructor.
Couldn't find constructor '{0}'.
Constructor bodies can't use 'async', 'async*', or 'sync*'.
Cannot invoke constructor '{0}' from a dynamic module.
A constructor tear-off can't have type arguments after the constructor name.
Constructors can't have a return type.
A constructor invocation can't have type arguments after the constructor name.
Constructors can't have type parameters.
The name of a constructor must match the name of the enclosing class.
The name of the enclosing class is '{0}'.
A 'continue' label must be on a loop or a switch member.
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.
Can't continue at '{0}' in a different function.
A continue statement in a switch statement must have a label as a target.
Couldn't infer type parameter '{0}'.{1}
Couldn't parse URI '{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.
Statements in {0} should be enclosed in a block.
toggle_on
Type '{0}' is a bound of itself via '{1}'.
'{0}' is a supertype of itself.
Cyclic definition of factory '{0}'.
An extension type can't depend on itself through its representation type.
The typedef '{0}' has a reference to itself.
'dart:ffi' can't be imported when compiling to Wasm.
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.
Fatal '{0}' at:
{1}
The declaration conflicts with setter '{0}'.
Conflicting setter '{0}'.
Can't declare a member that conflicts with an inherited one.
This is the inherited member.
This is one of the inherited members.
This is one of the overridden members.
A switch expression may not use the
default keyword.The default 'List' constructor isn't available when null safety is enabled.
Can't have a default value here because any default values of '{0}' would be used instead.
Default values aren't allowed in factory constructors that redirect to another constructor.
The deferred keyword should come immediately before the prefix ('as' clause).
Extension '{0}' cannot be imported through a deferred import.
Can't use the name '{0}' for a deferred library, as the name is used elsewhere.
'{0}' is used here.
The type '{0}' is deferred loaded via prefix '{1}' and can't be used as a type annotation.
The late local variable '{0}' is definitely unassigned at this point.
The imported package '{0}' isn't a dependency of the importing package.
toggle_on
Using a colon as the separator before a default value is deprecated and will not be supported in language
version 3.0 and later.
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
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}
'{0}' is deprecated and shouldn't be used.
'{0}' is deprecated and shouldn't be used. {1}
toggle_on
Using the 'new' keyword in a comment reference is deprecated.
Extending 'Function' is deprecated.
Implementing 'Function' has no effect.
Mixing in 'Function' is deprecated.
The public property isn't described by either 'debugFillProperties' or 'debugDescribeChildren'.
toggle_on
Indexed {0} libraries ({1} bytes) in {2}ms, that is,
{3} bytes/ms, and
{4} ms/libraries.
Type '{0}' can't use itself as a bound.
Directives must appear before any declarations.
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
Only a generic type, generic function, generic instance method, or generic constructor can have type arguments.
'Future'-returning calls in a non-'async' function.
toggle_on
Invalid use of an environment declaration.
toggle_on
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.
Missing documentation explaining why the diagnostic is ignored.
toggle_on
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}'.
A dot shorthand constructor invocation can't have type arguments.
No type was provided to find the dot shorthand '{0}'.
The static getter or field '{0}' isn't defined for the type '{1}'.
The static method or constructor '{0}' isn't defined for the type '{1}'.
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.
The first assigned variable pattern.
An import directive can only have one prefix ('as' clause).
The field '{0}' is already matched in this pattern.
The first field.
At most one rest element is allowed in a list or map pattern.
The first rest element.
'{0}' is already declared in this scope.
Previous declaration of '{0}'.
Can't use '{0}' because it is declared more than once.
'{0}' is exported from both '{1}' and '{2}'.
'{0}' is imported from both '{1}' and '{2}'.
The modifier '{0}' was already specified.
Duplicated named argument '{0}'.
Duplicated parameter name '{0}'.
Other parameter named '{0}'.
Duplicated record literal field name '{0}'.
This is the existing record literal field named '{0}'.
Duplicated record type field name '{0}'.
This is the existing record type field named '{0}'.
Dynamic calls are not allowed in a dynamic module.
Empty constructor bodies should be written using a ';' rather than '{}'.
toggle_on
An enum must declare at least one constant name.
Named parameter lists cannot be empty.
Optional parameter lists cannot be empty.
The list of named fields in a record type can't be empty.
toggle_on
Unable to decode bytes as UTF-8.
Enums can't declare abstract members.
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.
Enum constructors are constant so all fields must be final.
Enum constructors can't contain super-initializers.
Enum constructors can't be torn off.
An enum can't declare a non-abstract member named '{0}'.
An enum can't declare a member named 'values'.
An enum declaration can't be empty.
Enum factory constructors can't redirect to generative constructors.
'{0}' has 'Enum' as a superinterface and can't contain non-static members with name '{1}'.
'{0}' has 'Enum' as a superinterface and can't contain non-static member with name 'values'.
Enums can't be declared inside classes.
An enum can't inherit a member named '{0}'.
This is the inherited member
The result of instantiating the enum to bounds is not well-bounded.
Enums can't be instantiated.
Generative enum constructors must be marked as 'const'.
Non-abstract class '{0}' has 'Enum' as a superinterface.
The name 'values' is not a valid name for an enum.
The name 'values' is not a valid name for an enum. Try using a different name.
The enum must have at least one enum constant.
Missing a newline at the end of the file.
toggle_on
This is the previous use of the same key.
A comparison expression can't be an operand of another comparison expression.
Unsafe use of 'DartType' in an 'is' check.
Exception when reading '{0}': {1}
Missing case clauses for some constants in '{0}'.
toggle_on
Expected '{0}' after this.
Expected an initializer.
Expected a function body or '=>'.
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 a function body or '=>'.
Expected '{0}' before this.
Expected '{0}' or '{1}' before this.
Expected 'case' or 'default'.
Expected a class member, but got '{0}'.
Expected a class member.
Expected a declaration, but got '{0}'.
Expected 'else' or comma.
Expected a enum body, but got '{0}'.
Expected a method, getter, setter or operator declaration.
Expected a function body, but got '{0}'.
A hex digit (0-9 or A-F) must follow '0x'.
Expected an identifier, but got '{0}'.
'{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 named argument.
Expected a class name.
Expected a mixin name.
Expected the name of a class or mixin.
Expected one expression, but found additional input.
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 either an identifier or a string literal.
Expected a representation field.
Expected a representation type.
Expected a statement.
Expected a String, but got '{0}'.
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, but got '{0}'.
Expected a type name.
Expected a URI.
This requires the '{0}' language feature to be enabled.
This requires the '{0}' language feature, which requires language version of {1} or higher.
The experiment '{0}' has expired and can't be disabled.
The experiment '{0}' has expired and can't be enabled.
This requires the '{0}' language feature to be enabled.
This requires the experimental '{0}' language feature to be enabled.
This is the annotation that opts out this library from the '{0}' language feature.
The '{0}' language feature is disabled for this library.
The '{0}' language feature is disabled for this library.
'{0}' is experimental and could be removed or changed at any time.
Explicit extension application requires exactly 1 positional argument.
Explicit extension application cannot be used as an expression.
Explicit extension application cannot be a target for assignment.
Explicit extension application of extension '{0}' takes '{1}' type argument(s).
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.
This is exported 'main' declaration.
The variable '{0}' is unavailable in this expression evaluation.
This can't be used as an annotation; an annotation should be a reference to a compile-time constant variable,
or a call to a constant constructor.
'{0}' is an enum and can't be extended or implemented.
'{0}' is restricted and can't be extended or implemented.
Classes can't extend deferred classes.
The type 'Never' can't be used in an 'extends' clause.
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 instance fields
Extensions can't declare instance fields.
Extensions can't declare members with the same name as a member declared by 'Object'.
This extension member conflicts with Object member '{0}'.
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}'.
Extension overrides have no value so they can't be used as the receiver of a cascade expression.
An extension override can only be used to access instance members.
Extension type '{0}' inherits multiple members named '{1}' with incompatible signatures.
Extension type constructors can't declare super formal parameters.
Extension type constructors can't include super initializers.
The issue arises via this extension type declaration.
Extension types can't declare abstract members.
Extension types can't declare instance fields
Extension types can't declare instance fields.
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.
Extension types can't implement deferred types.
'{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.
This is the inherited extension type member.
This is one of the inherited extension type members.
Primary constructors in extension types can't use function formal parameter syntax.
Primary constructors in extension types can't use initializing formals.
The extension type representation can't depend on itself.
Cannot use extension type '{0}' in a dynamic module.
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 fields cannot have initializers.
External fields cannot have initializers.
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.
Fields in a struct class must have exactly one annotation indicating the native type.
Too many positional arguments: {0} expected, but {1} found.
Can't have modifier '{0}' here.
Can't have modifier '{0}' in an extension type.
Can't have modifier '{0}' in a primary constructor.
The factory conflicts with member '{0}'.
Conflicting member '{0}'.
Factory constructors can't be named 'new'.
Factory bodies can't use 'async', 'async*', or 'sync*'.
Top-level declarations can't be declared to be 'factory'.
A 'factory' constructor can't have initializers.
A non-redirecting 'factory' constructor must have a body.
Expected value after '{0}'.
Supported options:
-o , --output=
Generate the output into .
-h, /h, /?, -- help
Display this message (add -v for information about all options).
-v, --verbose
Display verbose information.
-Dname
-Dname=value
Define an environment variable in the compile-time environment.
--no-defines
Ignore all -D options and leave environment constants unevaluated.
--
Stop option parsing, the rest of the command line is assumed to be
file names or arguments to the Dart program.
--packages=
Use package resolution configuration , which should contain a mapping
of package names to paths.
--platform=
Read the SDK platform from , which should be in Dill/Kernel IR format
and contain the Dart SDK.
--target=dart2js|dart2js_server|dart2wasm|dart2wasm_js_compatibility|dart_runner|dartdevc|flutter|flutter_runner|none|vm
Specify the target configuration.
--enable-asserts
Check asserts in initializers during constant evaluation.
--verify
Check that the generated output is free of various problems. This is
mostly
useful for developers of this compiler or Kernel transformations.
--dump-ir
Print compiled libraries in Kernel source notation.
--omit-platform
Exclude the platform from the serialized dill file.
--exclude-source
Do not include source code in the dill file.
--compile-sdk=
Compile the SDK from scratch instead of reading it from a .dill file
(see --platform).
--sdk=
Location of the SDK sources for use when compiling additional platform
libraries.
--single-root-scheme=String
--single-root-base=
Specify a custom URI scheme and a location on disk where such URIs are
mapped to.
When specified, the compiler can be invoked with inputs using the custom
URI scheme. The compiler can ignore the exact location of files on disk
and as a result to produce output that is independent of the absolute
location of files on disk. This is mostly useful for integrating with
build systems.
--fatal=errors
--fatal=warnings
Makes messages of the given kinds fatal, that is, immediately stop the
compiler with a non-zero exit-code. In --verbose mode, also display
an
internal stack trace from the compiler. Multiple kinds can be separated
by
commas, for example, --fatal=errors,warnings.
--fatal-skip=
--fatal-skip= trace
Skip this many messages that would otherwise be fatal before aborting
the
compilation. Default is 0, which stops at the first message. Specify
'trace' to print a stack trace for every message without stopping.
--enable-experiment=
Enable or disable an experimental flag, used to guard features currently
in development. Prefix an experiment name with 'no-' to disable it.
Multiple experiments can be separated by commas.
Frequently used options:
-o Generate the output into .
- h Display this message (add -v for information about
all options).
Classes extending 'AbiSpecificInteger' must have exactly one const constructor, no other members, and
no type arguments.
Classes extending 'AbiSpecificInteger' must have exactly one 'AbiSpecificIntegerMapping' annotation specifying
the mapping from ABI to a NativeType integer with a fixed size.
Argument to 'Native.addressOf' must be annotated with @Native.
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.
{0} '{1}' can't implement Finalizable.
Subclasses of 'Struct' and 'Union' are backed by native memory, and can't be instantiated by a generative constructor.
Try allocating it via allocation, or load from a 'Pointer'.
Expected '{0}' to be a subtype of '{1}'.
Deeply immutable classes must be final or sealed.
Deeply immutable classes must only have final non-late instance fields.
Deeply immutable classes must only have deeply immutable instance fields. Deeply immutable types include 'int', 'double', 'bool', 'String', 'Pointer', 'Float32x4', 'Float64x2', 'Int32x4',
function types and classes annotated with
@pragma('vm:deeply-immutable').Subtypes of deeply immutable classes must be deeply immutable.
The super type of deeply immutable classes must be deeply immutable.
There may be at most one @DefaultAsset annotation on a library.
{0} '{1}' is empty. Empty structs and unions are undefined behavior.
Exceptional return value must not be null.
Exceptional return value must be a constant.
Argument '{0}' must be a constant.
Expected an exceptional return value for a native callback returning '{0}'.
Exceptional return value cannot be provided for a native callback returning '{0}'.
Class '{0}' cannot be extended or implemented.
Field '{0}' requires exactly one annotation to declare its native type, which cannot be Void. dart:ffi
Structs and Unions cannot have regular Dart fields.
{0} '{1}' contains itself. Cycle elements:
{2}
Field '{0}' is a dart:ffi Pointer to a struct field and therefore cannot be initialized before constructor execution.
Field '{0}' requires no annotation to declare its native type, it is a Pointer which is represented by
the same type in Dart and native code.
Field '{0}' cannot be nullable or have type 'Null', it must be
int, double,
Pointer, or a subtype of Struct or Union.FFI leaf call must not have Handle return type.
FFI leaf call must not have Handle argument types.
The return type of the function passed to NativeCallable.listener must be void rather than '{0}'.
Native functions and fields must not have more than @Native annotation.
The native type of this field could not be inferred and must be specified in the annotation.
Native fields must be static.
Unsupported type for native fields. Native fields only support pointers, compounds and numeric types.
The native type of this function couldn't be inferred so it must be specified in the annotation.
There may be at most one @DefaultAsset annotation on a library.
Native functions and fields must have exactly one
@Native annotation.Native functions and fields must be marked external.
Native functions must be declared external.
Only classes extending NativeFieldWrapperClass1 can be passed as Pointer.
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.
{0} expects a static function as parameter. dart:ffi only supports calling static Dart functions from
native code. Closures and tear-offs are not supported because they can capture context.
Struct '{0}' must have at most one 'Packed' annotation.
Only packing to 1, 2, 4, 8, and 16 bytes is supported.
Field '{0}' must have exactly one 'Array' annotation.
Field '{0}' must have an 'Array' annotation that matches the dimensions.
{0} '{1}' should not be generic.
Expected type '{0}' to be a valid and instantiated subtype of 'NativeType'.
Expected type '{0}' to be '{1}', which is the Dart type corresponding to '{2}'.
Variable length 'Array's must only occur as the last field of Structs.
'{0}' is a final instance variable that was initialized at the declaration.
'{0}' was initialized here.
Fields in subclasses of 'Struct' and 'Union' can't have initializers.
The field '{0}' can't be initialized twice in the same constructor.
Fields can't be initialized in both the primary constructor and at their declaration.
Fields can't be initialized in both the primary constructor parameter list and at their declaration.
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 of 'Struct' and 'Union' subclasses must be marked external.
This constructor should initialize field '{0}' because its type '{1}' doesn't allow null.
Field '{0}' should be initialized because its type '{1}' doesn't allow null.
'{0}' couldn't be promoted because there is a conflicting non-promotable field in class '{1}'.
'{0}' couldn't be promoted because there is a conflicting getter in class '{1}'.
'{0}' couldn't be promoted because there is a conflicting noSuchMethod forwarder in class '{1}'.
'{0}' refers to an external field so it couldn't be promoted.
'{0}' couldn't be promoted because field promotion is only available in Dart 3.2 and above.
'{0}' refers to a getter so it couldn't be promoted.
'{0}' refers to a non-final field so it couldn't be promoted.
'{0}' refers to a public property so it couldn't be promoted.
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'.
The class '{0}' can't be extended outside of its library because it's a final 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.
A constructor can't be declared to be 'final'.
Enums can't be declared to be 'final'.
Final field '{0}' is not initialized.
Final field '{0}' is not initialized by this constructor.
The final variable '{0}' must be initialized.
'{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'.
Final variable '{0}' must be assigned before it can be used.
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.
Final variable '{0}' might already be assigned at this point.
{0}
To-do comment doesn't follow the Flutter style.
toggle_on
A value of type '{0}' can't be assigned to a variable of type '{1}'.
A for-in loop can't have more than one loop variable.
Can't assign to this, so it can't be used in a for-in loop.
The type '{0}' used in the 'for' loop must implement '{1}'.
A for-in loop-variable can't be 'const'.
The type '{0}' used in the 'for' loop must implement '{1}' with a type argument that can be assigned
to '{2}'.
Can't have a default value in a function type.
Function-typed parameters can't specify 'const', 'final' or 'var' in place of a return type.
'sync*' and 'async*' can't return a value.
Generic function type '{0}' used as a type argument through typedef '{1}'.
Generic function types can't be used as type parameter bounds.
A generic function type can't be a type argument.
Type variables can't have generic function types in their bounds.
Generic function type '{0}' inferred as a type argument.
A generic function type can't be used as 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}'.
Getter not found: '{0}'.
The return type of getter '{0}' is '{1}' which isn't a subtype of the type '{2}' of its setter '{3}'.
A getter can't have formal parameters.
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 assignable to 'Stream'.
Functions marked 'async*' must have a return type that is a supertype of 'Stream' for some type 'T'.
Functions marked 'async*' can't have return type 'void'.
Functions marked 'async' must have a return type assignable to 'Future'.
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}.
The type '{0}' can't be mixed in.
Can't use '{0}' as a mixin because it has constructors.
This constructor prevents using '{0}' as a mixin.
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 assignable to 'Iterable'.
Functions marked 'sync*' must have a return type that is a supertype of 'Iterable' for some type 'T'.
Functions marked 'sync*' can't have return type 'void'.
The extension type '{0}' can't inherit the member '{1}' from more than one extension type.
The extension type '{0}' can't inherit the member '{1}' as both an extension type member and a non-extension
type member.
Import of a library in the 'lib/src' directory of another package.
toggle_on
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.
The type 'FutureOr' can't be used in an 'implements' clause.
The type 'Never' can't be used in an 'implements' clause.
'{0}' can't be used in both 'extends' and 'implements' clauses.
'{0}' can't be used in both the 'extends' and 'implements' clauses.
'{0}' can't be used in both the 'extends' and 'with' clauses.
Cannot invoke an instance of '{0}' because it declares 'call' to be something other than a method.
Applying the mixin '{0}' to '{1}' introduces an erroneous override of '{2}'.
The {0} '{1}' reopens '{2}' because it is not marked '{3}'.
toggle_on
A non-null value must be returned since the return type '{0}' doesn't allow null.
Cannot invoke
super because it declares 'call' to be something other than a method.The implicitly called unnamed constructor from '{0}' has required parameters.
The implicitly invoked unnamed constructor from '{0}' has required parameters.
The instance member '{0}' can't be accessed in an initializer.
Import directives must precede part directives.
The unavailable library '{0}' is imported through these packages:
{1}
Detailed import paths for (some of) the these imports:
{2}
The unavailable library '{0}' is imported through these paths:
{1}
The imported library defines a top-level function named 'loadLibrary' that is hidden by deferring this library.
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}'.
An element of kind '{0}' can't be replaced by an element of kind '{1}'.
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}.
The constructor function type '{0}' isn't a subtype of '{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.
Type argument '{0}' doesn't conform to the bound '{1}' of the type variable '{2}' on '{3}'.
Inferred type argument '{0}' doesn't conform to the bound '{1}' of the type variable '{2}' on '{3}'.
Type argument '{0}' doesn't conform to the bound '{1}' of the type variable '{2}' on '{3}'.
Inferred type argument '{0}' doesn't conform to the bound '{1}' of the type variable '{2}' on '{3}'.
Type argument '{0}' doesn't conform to the bound '{1}' of the type variable '{2}' on '{3}.{4}'.
Inferred type argument '{0}' doesn't conform to the bound '{1}' of the type variable '{2}' on '{3}.{4}'.
This is the type variable whose bound isn't conformed to.
Illegal parameter name '{0}' found during expression compilation.
Illegal type parameter name '{0}' found during expression compilation.
Index {0} is out of range 0..{1} of positional fields of records {2}.
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.
Can't inherit members that conflict with each other.
This is one inherited member.
This is the other inherited member.
A concrete instance member named '{0}' can't be inherited from '{1}' in a class that implements 'Enum'.
Tried to initialize from a previous compilation ({0}), but the file was not self-contained. This might
be a bug.
The Dart team would greatly appreciate it if you would take a moment to
report this problem at http://dartbug.com/new.
If you are comfortable with it, it would improve the chances of fixing any
bug if you included the file {1} in your error report, but be aware that this file includes your source code.
Either way, you should probably delete the file so it doesn't use unnecessary
disk space.
Tried to initialize from a previous compilation ({0}), but the file was not self-contained. This might
be a bug.
The Dart team would greatly appreciate it if you would take a moment to
report this problem at http://dartbug.com/new.
Tried to initialize from a previous compilation ({0}), but couldn't.
Error message was '{1}'.
Stacktrace included '{2}'.
This might be a bug.
The Dart team would greatly appreciate it if you would take a moment to
report this problem at http://dartbug.com/new.
If you are comfortable with it, it would improve the chances of fixing any
bug if you included the file {3} in your error report, but be aware that this file includes your source code.
Either way, you should probably delete the file so it doesn't use unnecessary
disk space.
Tried to initialize from a previous compilation ({0}), but couldn't.
Error message was '{1}'.
Stacktrace included '{2}'.
This might be a bug.
The Dart team would greatly appreciate it if you would take a moment to
report this problem at http://dartbug.com/new.
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.
'{0}' isn't an instance field of this class.
The type of parameter '{0}', '{1}' is not a subtype of the corresponding field's type, '{2}'.
The field that corresponds to the parameter.
Input file not found: {0}.
The static {0} '{1}' can't be accessed through an instance.
This instance member conflicts with the synthesized static member called '{0}'.
Instance property '{0}' conflicts with static property of the same name.
Conflicting static property '{0}'.
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 static type of the explicit instantiation operand must be a generic function type but is '{0}'.
The static type of the explicit instantiation operand must be a non-null generic function type but is '{0}'.
Too few type arguments: {0} required, {1} given.
Too many type arguments: {0} allowed, but {1} found.
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}'.
The integer literal {0} can't be represented in 64 bits.
The implementation of '{0}' in the non-abstract class '{1}' does not conform to its interface.
The class '{0}' can't be extended outside of its library because it's an interface class.
Enums can't be declared to be 'interface'.
A mixin can't be declared 'interface'.
A mixin class can't be declared 'interface'.
Attempt to set initializer on field without initializer.
Attempting to set body on abstract method.
No constructor named '{0}' in '{1}'.
Non-context message has context severity: {0}
Compilation aborted due to fatal '{0}' at:
{1}
Can't extend an unmodifiable scope.
Unexpected usage of label inside declaration of variables.
Compiler cannot run without a compiler context.
Couldn't find '{0}'.
Couldn't find '{0}' in '{1}'.
Unsupported omission of the type name in a constructor reference outside of an enum element declaration.
Couldn't find previous token.
Can't access private constructor '{0}'.
The compileSdk and sdkSummary options are mutually exclusive
{0}.stack isn't empty:
{1}
Expected '{0}', but got '{1}'.
Unhandled {0} in {1}.
Unimplemented {0}.
Unsupported operation: '{0}'.
Unsupported nullability value '{0}' on type '{1}'.
The URI '{0}' has no scheme.
Verification of the generated program failed:
{0}
Can't use string interpolation in a URI.
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.
A value of type '{0}' can't be assigned to a variable of type '{1}'.
'augment super' is only allowed in member augmentations.
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.
Can't break to '{0}'.
This expression is not valid in a 'case' clause in Dart 3.0.
toggle_on
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 expected type '{1}'.
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 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 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 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 local function has type '{0}' that isn't of expected type '{1}'.
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 static method has type '{0}' that isn't of expected type '{1}'.
The top level function has type '{0}' that isn't of expected type '{1}'.
A change of type '{0}' can't be used for an element of kind '{1}'.
Invalid character '{0}'.
The escape sequence '{0}' isn't a valid code point.
The escape sequence starting with '\u' 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 binary operator {0} is not supported as a constant pattern.
The expression can't be prefixed by 'const' to form 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.
Can't continue at '{0}'.
The 'covariant' modifier can only be used on non-final declaring parameters.
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 string '' can't stand alone.
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 representation type '{0}' of extension type '{1}' must be either a subtype of the representation
type '{2}' of the implemented extension type '{3}' or a subtype of '{3}' itself.
The implemented interface '{0}' must be a supertype of the representation type '{1}' of extension type '{2}'.
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.
The type '{0}' of the getter '{1}' is not a subtype of the type '{2}' of the setter '{3}'.
The type '{0}' of the inherited field '{1}' is not a subtype of the type '{2}' of the inherited setter '{3}'.
The type '{0}' of the inherited getter '{1}' is not a subtype of the type '{2}' of the inherited setter '{3}'.
This is the declaration of the field '{0}'.
The type '{0}' of the inherited field '{1}' is not a subtype of the type '{2}' of the setter '{3}'.
This is the declaration of the getter '{0}'.
The type '{0}' of the inherited getter '{1}' is not a subtype of the type '{2}' of the setter '{3}'.
This is the declaration of the setter '{0}'.
The type '{0}' of the field '{1}' is not a subtype of the type '{2}' of the inherited setter '{3}'.
The type '{0}' of the getter '{1}' is not a subtype of the type '{2}' of the inherited setter '{3}'.
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.
Inline function types cannot 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.
Keys must be of type 'String' but found the type '{0}'.
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'.
'{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.
Invalid package URI '{0}':
{1}.
The parameter style must be one of the following: {0}.
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.
The key 'requiredIf' can only be used with optional named parameters.
A value of type '{0}' can't be returned from a function with return type '{1}'.
A value of type '{0}' can't be returned from an async function with return type '{1}'.
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'.
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 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.
Invalid modifier 'sync'.
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}'.
Can't use implicitly 'out' variable '{0}' in an '{1}' position in supertype '{2}'.
Can't use '{0}' type variable '{1}' in an '{2}' position in supertype '{3}'.
Can't use '{0}' type variable '{1}' in an '{2}' position.
Can't use '{0}' type variable '{1}' in an '{2}' position in the return type.
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.
Cannot use '?.' here.
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 value of '{0}' should be of type '{1}' but is of type '{2}'.
The value of '{0}' must be one of the following: '{1}'.
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'.
Type 'void' can't be used here.
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.
toggle_on
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.
'{0}' isn't a function or method and can't be invoked.
toggle_on
Assignment could be inlined in 'return' statement.
toggle_on
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.
Variable pattern '{0}' doesn't have the same type or finality in all cases.
Dart class '{0}' cannot extend JS interop class '{1}'.
The '@JS' annotation from 'dart:js_interop' can only be used for static interop, either through extension
types or '@staticInterop' classes.
Member has a JS interop annotation but the enclosing class does not.
This is the enclosing class.
Class '{0}' does not have a
@JSExport on it or any of its members.The value in the
@JSExport annotation on the class or mixin '{0}' will be ignored.Member '{0}' is not a concrete instance member or declares type parameters, and therefore can't be exported.
Type argument '{0}' needs to be a non-JS interop type.
Type argument '{0}' needs to be an interface type.
The following class members collide with the same export '{0}': {1}.
Class '{0}' has no exportable members in the class or the inheritance chain.
Extension type member is marked 'external', but the representation type of its extension type is not
a valid JS interop type.
Extension type '{0}' is marked with a '@JS' annotation, but its representation type is not a valid JS
interop type: '{1}'.
Extension types should use the '@JS' annotation from 'dart:js_interop' and not from 'package:js'.
JS interop type or @Native type from an SDK web library required for 'external' extension members.
External extension members with the keyword 'static' on JS interop and @Native types are disallowed.
Only JS interop members may be 'external'.
Functions converted via '{0}' cannot declare named parameters.
Functions converted via '{0}' require a statically known function type, but Type '{1}' is not a precise
function type, e.g.,
void Function().Functions converted via '{0}' cannot declare type parameters.
Function converted via '{0}' contains invalid types in its function signature: '{1}'.
JS interop static class members cannot have '.' in their JS name.
Type argument '{0}' provided to 'isA' cannot be a type variable and must be an interop extension type
that can be determined at compile-time.
Type argument '{0}' has an object literal constructor. Because 'isA' uses the type's name or '@JS()' rename,
this may result in an incorrect type check.
Type argument '{0}' wraps primitive JS type '{1}', which is specially handled using 'typeof'.
'isA' can't be torn off.
JS interop class '{0}' cannot extend Dart class '{1}'.
Named parameters for JS interop functions are only allowed in object literal constructors or @anonymous factories.
Non-static JS interop class '{0}' conflicts with natively supported class '{1}' in '{2}'.
JS interop classes do not support non-external constructors.
This JS interop member must be annotated with
external. Only factories and static methods
can be non-external.Class '{0}' does not have an
@staticInterop annotation, but has supertype '{1}', which does.{0} should not contain any positional parameters.
JS interop operator methods cannot be renamed using the '@JS' annotation.
JS interop types do not support overloading external operator methods, with the exception of '[]' and '[]='
using static interop.
External JS interop member contains an invalid type: '{0}'.
External JS interop member contains invalid types in its function signature: '{0}'.
@staticInterop classes should not contain any generative constructors.Dart class '{0}' has a {1}, but does not have a {2} to implement any of the following extension member(s)
with export name '{3}': {4}.
Dart class '{0}' does not have any members that implement any of the following extension member(s) with
export name '{1}': {2}.
Type argument '{0}' needs to be a
@staticInterop type.Type argument '{0}' has type parameters that do not match their bound. createStaticInteropMock requires
instantiating all type parameters to their bound to ensure mocking conformance.
@staticInterop classes should also have the @JS annotation.Initializers for parameters are ignored on static interop external functions.
Synthetic constructors on
@staticInterop classes can not be used.Tear-offs of external {0} '{1}' are disallowed.
JS interop class '{0}' has an
@trustTypes annotation, but @trustTypes is only
supported within the sdk.JS interop class '{0}' has an
@trustTypes annotation, but no @staticInterop
annotation.JS interop class '{0}' with
@staticInterop annotation cannot declare instance members.JS interop class '{0}' has an
@staticInterop annotation, but has supertype '{1}', which
does not.Can't find label '{0}'.
The language version is not specified correctly in the packages file.
This is language version annotation in the library.
The language version override has to be the same in the library and its part(s).
The language version override has to be the same in the library and its patch(es).
This is language version annotation in the part.
This is language version annotation in the patch.
The specified language version {0}.{1} is too high. The highest supported language version is {2}.{3}.
The language version {0}.{1} specified for the package '{2}' is too high. The highest supported language
version is {3}.{4}.
The specified language version {0}.{1} is too low. The lowest supported language version is {2}.{3}.
The language version {0}.{1} specified for the package '{2}' is too low. The lowest supported language
version is {3}.{4}.
Late final variable '{0}' definitely assigned.
Late variable '{0}' without initializer is definitely unassigned.
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.Missing a newline at the beginning of a multiline string.
toggle_on
The library directive must appear before all other directives.
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.
The element type '{0}' can't be assigned to the list type '{1}'.
List literal requires exactly one type argument.
A list pattern requires exactly one type argument.
toggle_on
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'.
'loadLibrary' takes no arguments.
Local function declarations can't specify any modifiers.
Local variable '{0}' can't be referenced before it is declared.
This is the declaration of the variable '{0}'.
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 'main' declaration must be a function declaration.
The exported 'main' declaration must be a function declaration.
The 'main' method cannot have required named parameters.
The exported 'main' method cannot have required named parameters.
The 'main' method must have at most 2 required parameters.
The exported 'main' method must have at most 2 required parameters.
The type '{0}' of the first parameter of the 'main' method is not a supertype of '{1}'.
The type '{0}' of the first parameter of the exported 'main' method is not a supertype of '{1}'.
The element type '{0}' can't be assigned to the map key type '{1}'.
A map pattern requires exactly two type arguments.
The element type '{0}' can't be assigned to the map value type '{1}'.
The super parameter named '{0}'' does not share the same name as the corresponding parameter in the super constructor, '{1}'.
toggle_on
The member conflicts with constructor '{0}'.
Conflicting constructor '{0}'.
The member conflicts with factory '{0}'.
Conflicting factory '{0}'.
Member not found: '{0}'.
Cannot invoke member '{0}' from a dynamic module.
Cannot override member '{0}.{1}' in a dynamic module.
A class member can't have the same name as the enclosing class.
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.
Method not found: '{0}'.
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.
The closing parenthesis is missing.
The code block is missing a specified language.
toggle_on
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'.
Constant expression expected.
Numbers in exponential notation should always contain an exponent (an integer number with an optional sign).
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.
A function declaration needs an explicit list of parameters.
Functions must have an explicit list of parameters.
Getters must have the keyword 'get' before the getter name.
Hexadecimal digit expected.
Expected an identifier.
'{0}' is defined here.
The non-abstract class '{0}' is missing implementations for these members:
{1}
No input file provided to the compiler.
Missing the required key '{0}'.
No 'main' method found.
A method declaration needs an explicit list of parameters.
Methods must have an explicit list of parameters.
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.
The getter name is not specified explicitly, and the pattern is not a variable.
The super constructor has no corresponding named parameter.
Exactly one of the following keys must be provided: {0}.
Operator declarations must be preceded by the keyword 'operator'.
Missing a required override of '{0}' and '{1}'.
Missing a required override of '{0}', '{1}', and {2} more.
Missing a required override of '{0}'.
Can't use '{0}' as a part, because it has no 'part of' declaration.
The super constructor has no corresponding positional parameter.
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 ('*').
Missing the end brace for the template.
There is no '{0}' to close the parameter group.
Expected to find {0}.
A typedef needs an explicit list of parameters.
Typedefs must have an explicit list of parameters.
At least one URI must be provided.
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.
Missing whitespace between adjacent strings.
toggle_on
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}' doesn't implement '{1}' so it can't be used with '{2}'.
The class doesn't have a concrete implementation of the super-accessed member '{0}'.
This is the super-access that doesn't have a concrete target.
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-accessed setter '{0}'.
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}'.
'{0}' can't be mixed onto '{1}' because '{1}' doesn't implement '{2}'.
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.
Classes can't mix in deferred mixins.
Type parameters couldn't be inferred for the mixin '{0}' because '{1}' does not implement the mixin's
supertype constraint '{2}'.
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.
The mixin '{0}' must be 'base' because the supertype '{1}' is 'base'.
The mixin '{0}' must be 'base' because the supertype '{1}' is 'final'.
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}'.
Can't have more than one 'super' initializer.
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 definition can have at most one implements 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.
Multiple plugins can't be enabled.
Can't have multiple groups of positional parameters in a single parameter list.
Only one primary constructor body declaration is allowed.
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}'.
Undefined name '{0}'.
Field name {0} isn't found in records of type {1}.
Record field names can't be a dollar sign followed by an integer when integer is the index of a positional field.
A function expression can't have a name.
Function expressions can't be named.
Function types can't be named.
The mixin application class '{0}' introduces an erroneous override of '{1}'.
Named parameters must be enclosed in curly braces ('{' and '}').
Extension type declarations can't have named parameters.
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.
null encountered as case in a switch expression with a non-nullable enum type.null encountered as case in a switch expression with a non-nullable type.null encountered as case in a switch statement with a non-nullable type.null encountered as the result from expression with type Never.'new' can only be used as a constructor reference.
Constructors declared with the 'new' keyword can't use '.' before the constructor name.
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.
Cannot call 'augment super'.
Cannot read from 'augment super'.
Cannot write to 'augment super'.
Can't infer missing types in '{0}' from overridden methods: {1}.
Invalid use of 'default' member in a switch.
toggle_on
The superclass '{0}' doesn't have a zero argument constructor.
The value of the case clause ('{0}') is equal to the value of an earlier case clause ('{1}').
toggle_on
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 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.
No named parameter with the name '{0}'.
The default "android.hardware.touchscreen" needs to be optional for Chrome OS.
Don't create string literals with trailing spaces in tests.
'Object' has no 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}'.
The non-ASCII character '{0}' ({1}) can't be used in identifiers, only in strings and comments.
The non-ASCII space character {0} can only be used in strings and comments.
This is the existing declaration.
This is the existing member.
This instance creation must be 'const', because the {0} constructor is marked as '@literal'.
Cannot invoke a non-'const' constructor where a const expression is expected.
Cannot invoke a non-'const' factory where a const expression is expected.
A non-constant map or set literal without type arguments can't be used as an expression statement.
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 variable name '{0}' isn't a lowerCamelCase identifier.
toggle_on
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.
An extension type parameter can't be used non-covariantly in its representation type.
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}' is not exhaustively matched by the switch cases since it doesn't match '{1}'.
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}' is not exhaustively matched by the switch cases since it doesn't match '{1}'.
The type '{0}' isn't exhaustively matched by the switch cases since it doesn't match the pattern '{1}'.
This is the inherited non-extension type member.
This is one of the inherited non-extension type members.
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.
Can't spread a value with static type '{0}'.
Non-nullable variable '{0}' must be assigned before it can be used.
The part-of directive must be the only directive in a part.
Array dimensions must be positive numbers.
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 OSBound of this variable references raw type '{0}'.
Bound of this variable references variable '{0}' from the same declaration.
The 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.
The return type of the operator []= must be 'void'.
The return type of the setter must be 'void' or absent.
The expression has no effect and can be removed.
toggle_on
Normal parameters must occur before optional parameters.
Not a constant expression.
'{0}.{1}' can't be used as a type because '{0}' doesn't refer to an import prefix.
This isn't a type.
Can't assign to this.
The non-nullable local variable '{0}' must be assigned before it can be used.
{0} is not a constant expression.
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.
'{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 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
Can't use an expression of type '{0}' as a function because it's potentially null.
Can't implement '{0}' because it's nullable.
Method '{0}' cannot be called on '{1}' because it is potentially null.
Can't mix '{0}' in because it's nullable.
Operator '{0}' cannot be called on '{1}' because it is potentially null.
Property '{0}' cannot be accessed on '{1}' because it is potentially null.
An expression whose value can be 'null' must be null-checked before it can be dereferenced.
Can't extend '{0}' because it's nullable.
Can't tear off method '{0}' from a potentially null value.
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.
The class 'Object' can't extend any other class.
The class 'Object' can't have a superclass.
The class 'Object' can't implement anything.
Record field names can't be the same as a member from 'Object'.
The class 'Object' can't use mixins.
Using a colon as a separator before a default value is no longer supported.
Using a colon as the separator before a default value is no longer supported.
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
A try block must be followed by an 'on', 'catch', or 'finally' clause.
Operator '{0}' should have zero or one parameter.
Operator '{0}' shouldn't have any parameters.
Operator '{0}' should have exactly one parameter.
Operator '{0}' should have exactly two parameters.
An operator can't have optional parameters.
Types parameters aren't allowed when defining an operator.
The parameter '{0}' can't have a value of 'null' because of its type '{1}', but the implicit default
value is 'null'.
Optional parameters aren't allowed when defining an operator.
Extension type declarations can't have optional parameters.
Type '{0}' of the optional super-initializer parameter '{1}' doesn't allow 'null', but the parameter doesn't
have a default value, and the default value can't be copied from the corresponding parameter of the super constructor.
The '{0}' clause must come before the '{1}' clause.
This is the overridden method ('{0}').
The method '{0}' has fewer named arguments than those of overridden method '{1}'.
The method '{0}' has fewer positional arguments than those of overridden method '{1}'.
The method '{0}' doesn't have the named parameter '{1}' of overridden method '{2}'.
The required named parameter '{0}' in method '{1}' is not required in overridden method '{2}'.
The method '{0}' has more required arguments than those of overridden method '{1}'.
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 parameter '{0}' of the method '{1}' has type '{2}', which does not match the corresponding type, '{3}',
in the overridden method, '{4}'.
The return type of the method '{0}' is '{1}', which does not match the return type, '{2}', of the overridden method, '{3}'.
The field '{0}' has type '{1}', which does not match the corresponding type, '{2}', in the overridden setter, '{3}'.
Declared bound '{0}' of type variable '{1}' of '{2}' doesn't match the bound '{3}' on overridden method '{4}'.
Declared type variables of '{0}' doesn't match those on overridden method '{1}'.
Missing documentation for public API.
toggle_on
The package name '{0}' isn't a lower_case_with_underscores identifier.
toggle_on
Couldn't resolve the package '{0}' in '{1}'.
The library name is not a dot-separated path prefixed by the package name.
toggle_on
Problem in packages configuration file: {0}
Invalid assignment to the parameter '{0}'.
toggle_on
Can't export this file because it contains a 'part of' declaration.
This is the file that can't be exported.
A file that's a part of a library can't have parts itself.
This is the containing library.
Can't import '{0}', because it has a 'part of' declaration.
Using '{0}' as part of '{1}' but its 'part of' declaration says '{2}'.
The 'part of' directive can't use a name with the enhanced-parts feature.
A file can't be a part of itself.
Only one part-of directive may be declared in a file.
A file can't be part of more than one library.
Used as a part in this library.
The library is unnamed. A URI is expected, not a library name '{0}', in the part-of directive.
Using '{0}' as part of '{1}' but its 'part of' declaration says '{2}'.
Using '{0}' as part of '{1}' but its 'part of' declaration says '{2}'.
This part doesn't have a containing library.
Can't use '{0}' as a part more than once.
A part cannot have a library directive.
This is the origin class.
A patch class must have the same number of type variables as its origin class.
This is the origin declaration.
This is the origin extension.
A patch extension must have the same number of type variables as its origin extension.
Can't inject public '{0}' into '{1}'.
Variable '{0}' can't be declared in a pattern assignment.
Only local variables can be assigned in pattern assignments.
Only local variables or formal parameters can be used in pattern assignments.
Constant values from a deferred library can't be used in patterns.
Pattern matching error
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,
Can't access platform private library.
Plugins can only be specified in the root of a pub workspace or the root of a package that isn't in a workspace.
Place positional arguments before named arguments.
Positional arguments must occur before named arguments.
Positional parameters must be enclosed in square brackets ('[' and ']').
Positional optional parameters can't use ':' to specify a default value.
Positional super parameters can't be used when the super constructor invocation has a positional argument.
Positional super-initializer parameters cannot be used when the super initializer has positional arguments.
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
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.
A primary constructor body requires a primary constructor declaration.
A primary constructor can't be a redirecting constructor.
The private name '{0}', defined by '{1}', conflicts with the same name defined by '{2}'.
A named parameter that doesn't refer to an instance variable can't start with an underscore ('_').
Named parameters that don't refer to instance variables can't start with underscore.
A named parameter can't start with an 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.
A private named parameter must have a corresponding public name.
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.
Record field names can't be private.
A record literal with exactly one positional field requires a trailing comma.
A record literal with exactly one positional field requires a trailing comma.
A record literal without fields can't have a trailing comma.
A record type with exactly one positional field requires a trailing comma.
A record type without fields can't have a trailing comma.
RecordUse annotation cannot be placed on this element.RecordUse annotations are only supported in libraries with a package: URI.The 'call' property on the record type isn't directly callable but could be invoked by
.call(...)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.
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.
A redirecting constructor can't have other initializers.
Redirecting constructors can't have a body.
A redirecting constructor can't have more than one redirection.
A redirecting constructor can't have a 'super' initializer.
The type '{0}' doesn't extend '{1}'.
Only factory constructor can specify '=' redirection.
Redirection constructor target not found: '{0}'
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'.
Remove deprecated elements in breaking versions.
toggle_on
'{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.
Missing a required trailing comma.
toggle_on
Named parameter '{0}' is required and can't have a default value.
Non-optional parameters can't have a default value.
The '...' pattern can't appear in map patterns.
'rethrow' can only be used in catch clauses.
Can't return a value from a void function.
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.
A value must be explicitly returned from a non-void async function.
A value must be explicitly returned from a non-void function.
A part file cannot have script tag.
SDK root directory not found: {0}.
SDK libraries specification not found: {0}.
SDK summary not found: {0}.
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 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 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.
The class '{0}' can't be extended, implemented, or mixed in outside of its library because it's a sealed class.
Enums can't be declared to be 'sealed'.
A mixin can't be declared 'sealed'.
A mixin class can't be declared 'sealed'.
The element type '{0}' can't be assigned to the set type '{1}'.
A set or map literal requires exactly one or two type arguments, respectively.
The setter conflicts with declaration '{0}'.
Conflicting declaration '{0}'.
Constructors can't be a setter.
Setters can't be defined within methods or functions.
Setter not found: '{0}'.
Setters can't use 'async', 'async*', or 'sync*'.
A setter should have exactly one formal parameter.
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 prefix of a deferred import can't be used in other import directives.
The {0} identification '{1}:' is redundant and can be removed.
toggle_on
'Array's must have an 'Array' annotation that matches the dimensions.
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
Built bodies for {0} compilation units ({1} bytes) in {2}ms, that is,
{3} bytes/ms, and
{4} ms/compilation unit.
Built outlines for {0} compilation units ({1} bytes) in {2}ms, that is,
{3} bytes/ms, and
{4} ms/compilation unit.
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
Iterable spread.
Can't assign spread elements of type '{0}' to collection elements of type '{1}'.
Constant values from a deferred library can't be spread into a const literal.
Map spread.
Can't assign spread entry keys of type '{0}' to map entry keys of type '{1}'.
Can't assign spread entry values of type '{0}' to map entry values of type '{1}'.
Unexpected type '{0}' of a map spread entry. Expected 'dynamic' or a Map.
Unexpected type '{0}' of a spread. Expected 'dynamic' or an Iterable.
The file has too many nested expressions or statements.
Instance member '{0}' can't be accessed using static access.
Static property '{0}' conflicts with instance property of the same name.
Conflicting instance property '{0}'.
Constructors can't be static.
A 'static' getter must have a body.
Operators can't be static.
A 'static' setter must have a body.
Cannot access static member on an instantiated generic class.
The generic type '{0}' should have explicit type arguments but doesn't.
Missing type annotation.
toggle_on
The type '{0}' must be 'base', 'final' or 'sealed' because the supertype '{1}' is 'base'.
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 type '{0}' must be 'base', 'final' or 'sealed' because the supertype '{1}' is 'final'.
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'.
Can't use 'super' as an expression.
Expected identifier, but got 'super'.
If you want '{0}' to be a super-bounded type, note that the inverted type '{1}' must then satisfy its bounds,
which it does not.
The type '{0}' can't be implemented by an extension type.
The type '{0}' which is an alias of '{1}' can't be implemented by an extension type.
The type '{0}' which is an alias of '{1}' can't be implemented by an extension type because it is nullable.
The type variable '{0}' can't be implemented by an extension type.
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.
toggle_on
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.
The class 'Object' can't invoke a constructor from a superclass.
Can't have initializers after 'super'.
This is the super-initializer parameter.
The operator '?.' cannot be used with 'super' because 'super' cannot be null.
Super-initializer formal parameters can only be used in generative constructors.
Superclass has no constructor named '{0}'.
The superclass, '{0}', has no unnamed constructor that takes no arguments.
Superclass has no getter named '{0}'.
Superclass has no member named '{0}'.
Superclass has no method named '{0}'.
Superclass has no setter named '{0}'.
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.
Can't use a function type as supertype.
The type '{0}' can't be used as supertype.
The type '{0}' which is an alias of '{1}' can't be used as supertype.
The type '{0}' which is an alias of '{1}' can't be used as supertype because it is nullable.
The type variable '{0}' can't be used as supertype.
Switch case may fall through to the next case.
Type '{0}' of the switch expression isn't assignable to the type '{1}' of case expressions.
The switch expression is here.
Type '{0}' of the case expression is not a subtype of type '{1}' of this switch expression.
The default case should be the last case in a switch statement.
The 'default' case can only be declared once.
This couldn't be parsed.
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.
Can't access 'this' in a field initializer to read '{0}'.
Expected identifier, but got 'this'.
'this' can't be promoted.
Can't access '{0}' in a field initializer.
The type '{0}' of the thrown expression must be assignable to 'Object'.
Can't throw a value of '{0}' since it is neither dynamic nor non-nullable.
Use a type annotation rather than 'assert' to enforce non-nullability.
toggle_on
{0}
Too few positional arguments: {0} required, {1} given.
Too many positional arguments: {0} allowed, but {1} found.
The type of '{0}' can't be inferred because it depends on itself through the cycle: {1}.
Operators must be declared within a class.
Variables can't be declared using both 'var' and a type name.
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.
Expected {0} type arguments.
'{0}' doesn't conform to the bound '{1}' of the type parameter '{2}'.
Can't use type arguments with type variable '{0}'.
Factory constructors cannot have a return type.
Tests for non-null should be done with '!= null'.
Tests for null should be done with '== null'.
Type '{0}' not found.
'{0}' is from '{1}'.
'{0}' is from '{1}' ('{2}').
A type variable can't have the same name as another.
The other type variable named '{0}'.
Static members can't reference type parameters of the class.
A type variable can't have the same name as its enclosing declaration.
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.
Type variables can't be used as constants.
Type variables can't be used in static members.
The issue arises via this type alias.
Typedefs can't be declared inside classes.
Can't create typedef from non-function type.
Can't create typedef from non-type.
Can't create typedef from nullable type.
Can't use a typedef denoting a type variable as a constructor, nor for a static member access.
This is the type variable ultimately denoted.
This is the type denoted by the type alias.
Unable to get content of '{0}'.
Dart library '{0}' is not available on this platform.
Missing an 'await' for the 'Future' computed by this expression.
toggle_on
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}'.
The variable '{0}' isn't defined.
{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.
Super parameters can only be used in non-redirecting generative constructors.
There is no '{0}' to open a parameter group.
Unexpected text '{0}'.
Unexpected token '{0}'.
Unexpected tokens.
Didn't expect to find {0}.
The diagnostic '{0}' can't be ignored.
The accessor '{0}' is invalid.
Augmentation class '{0}' doesn't match a class in the augmented library.
Augmentation member '{0}' doesn't match a member in the augmented class.
Augmentation '{0}' doesn't match a declaration in the augmented library.
Augmentation member '{0}' doesn't match a member in the augmented library.
Patch class '{0}' doesn't match a class in the origin library.
Patch member '{0}' doesn't match a member in the origin class.
Patch '{0}' doesn't match a declaration in the origin library.
Patch member '{0}' doesn't match a member in the origin library.
Can't find '{0}' to match '{1}'.
A pattern field in an object pattern must be named.
Don't make a function 'async' if it doesn't use 'await'.
toggle_on
Unnecessary 'await'.
toggle_on
Unnecessary 'break' statement.
toggle_on
The dev dependency on {0} is unnecessary because there is also a normal dependency on that package.
Local variables should not be marked as 'final'.
The keyword 'final' isn't necessary because the parameter is implicitly 'final'.
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
The import of '{0}' is unnecessary because all of the used elements are also provided by the import of '{1}'.
Library directives without comments or annotations should be avoided.
toggle_on
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.
Unnecessary use of a null-aware operator to invoke an extension method on a nullable type.
toggle_on
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.
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
None of the patterns in the switch expression the matched input value. See https://github.com/dart-lang/language/issues/3488
for details.
None of the patterns in the exhaustive switch statement the matched input value. See https://github.com/dart-lang/language/issues/3488
for details.
{0}
The getter name is not specified explicitly, and the pattern is not a variable. Try specifying the getter
name explicitly, or using a variable pattern.
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.
Dart native extensions are no longer supported.
The key '{0}' isn't supported.
The '{0}' operator is not supported.
Using stub implementations for APIs in platform-specific Dart library
'{0}', which will throw 'UnsupportedError' if invoked.
'+' is not a prefix operator.
The key 'static' is only supported for elements in a class, enum, extension, or mixin.
Only version '1' is supported at this time.
Comment starting with '/' must end with '/'.
Unterminated multi-line comment.
String starting with {0} must end with {1}.
Unterminated string literal.
Incomplete token.
Not found: '{0}'
The exception variable '{0}' isn't used, so the 'catch' clause can be removed.
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
Dart native extensions are deprecated and aren't available in Dart 2.15.
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
Required named parameter '{0}' must be provided.
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'.
Variable '{0}' could not be promoted due to an assignment.
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}'.
The node most likely is taken from here by a transformer.
Declare 'visit' methods for all registered node types.
This expression has type 'void' and can't be used.
Type 'void' can't have type arguments.
WebAssembly elements may only be referenced to directly call a method on them.
The receiver of this call must be a top-level variable describing the WebAssembly element.
This external getter returns a memory instance, but no annotation describing it was found
Pragmas
wasm:import and wasm:export are for internal use only and cannot be
used by user code.This intrinsic extension member may not be torn off.
Return and argument types of a weak reference should match.
Weak reference should take one required positional argument.
Weak reference pragma can be used on a static method only.
Return type of a weak reference should be nullable.
The target of weak reference should not take parameters.
The target of weak reference should be a tearoff of a static method.
The integer literal {0} can't be represented exactly in JavaScript.
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 dot shorthand resolves to the constructor '{0}.{1}', and type parameters can't be applied to dot
shorthand constructor invocations.
The {0} '{1}' is declared with {2} type parameters, but {3} type arguments are given.
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 type of this function is '{0}', which has {1} type parameters, but {2} type arguments were given.
The default value of a positional parameter should be preceded by '='.
Expected '{0}' to close parameter group.
Expected to find {0}, but found {1}.
'{0}' can't be used contravariantly or invariantly in '{1}'.
The '{0}' type parameter '{1}' can't be used in an '{2}' position.
Parse error: {0}
'yield' can't be used as an identifier in 'async', 'async*', or 'sync*' methods.
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*').
'yield' can only be used in 'sync*' or 'async*' methods.
A yielded value of type '{0}' must be assignable to '{1}'.
The type '{0}' implied by the 'yield*' expression must be assignable to '{1}'.
Was this page's content helpful?
Unless stated otherwise, the documentation on this site reflects Dart 3.11.0. Page last updated on 2025-09-15. View source or report an issue.