Google Git
Sign in
dart / sdk.git / refs/tags/3.6.0-112.0.dev / . / pkg / front_end / messages.yaml
blob: 104e90315f2d8a190b6645dda353927fef2bbefb [file] [log] [blame]
# Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.
# Run
#
# dart run pkg/front_end/tool/_fasta/generate_messages.dart
#
# to regenerate messages after having edited this file.
#
# If entries with 'analyzerCode', 'sharedName', or 'index' have been changed,
# run
#
# dart run pkg/analyzer/tool/messages/generate.dart
#
# to regenerate analyzer messages.
# Each entry in this map corresponds to a diagnostic message. Ideally, each
# entry contains three parts:
#
# 1. A message template (problemMessage).
#
# 2. A suggestion for how to correct the problem (correctionMessage).
#
# 3. Examples that produce the message (one of expression, statement,
# declaration, member, script, bytes or external). Note that 'external'
# should be the path to an external test. The external test will not be run,
# but the existence of the file will be verified.
#
# Multiple scripts can start with a `// @dart=` annotation to enforce the
# language version used for the example code.
#
# Note that it can be hard or impossible to write an example that only gives the
# specific error. To allow for this, one can specify
# "exampleAllowMoreCodes: true" which filters out every message with a
# different code, and just verifies we got exactly one message of the code in
# question (in addition too different codes).
#
# A message shouldn't indicate which kind of diagnostic it is, for example,
# warning or error. Tools are expected to prepend "Warning: ", or "Error: ",
# and should be allowed to change the kind of diagnostic without affecting the
# message. For example, an error might be turned into a warning by the tool.
#
# See the file [lib/src/fasta/diagnostics.md] for more details on how to write
# good diagnostic messages.
#
# A message used for internal errors should have key that starts with
# "InternalProblem". This way, UX review can prioritize it accordingly.
#
# Eventually, we'd like to have all diagnostics in one shared
# location. However, for now, the analyzer needs to translate error codes to
# its own format. To support this, an entry can contain an analyzer error code
# (analyzerCode).
#
# Long term, the analyzer and front-end need to share the same error codes. So
# eventually all error codes should have an `analyzerCode` field.
# Any error code with an `index` field and an `analyzerCode` field
# will be auto generated as an Analyzer error code.
# `index` field values should be unique, consecutive whole numbers starting with 1.
# If `index` is defined, then `analyzerCode` should be the fully formed
# name of the corresponding public Analyzer error const
# (e.g. ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND)
# which will be used when generating code in Analyzer for translating
# fasta error codes to Analyzer error codes.
# If `sharedName` is defined, the generated analyzer code will use this as the
# user-facing analyzer code instead of `analyzerCode`. Multiple messages can share
# the `sharedName`.
#
# Errors with an `index` can also optionally contain user-facing documentation
# for the problem (documentation), which will be extracted to
# `pkg/analyzer/tool/diagnostics/diagnostics.md`, as well as internal
# documentation (comment), which will be included in the code generated for the
# analyzer.
#
# In some cases a message is internal to the frontend, and no meaningful
# analyzer code can be provided. In such cases set `frontendInternal: true`.
#
# ## Parameter Substitution in problemMessage and correctionMessage
#
# The fields `problemMessage` and `correctionMessage` are subject to parameter
# substitution. When the compiler reports a problem, it may also specify a map
# with the following keys to be substituted into the message:
#
# `#character` a Unicode character.
#
# `#unicode` a Unicode short identifier (U+xxxx). We use this to represent code
# units or code points.
#
# `#name`, `#name2`, `#name3`, `#name4`: names (as strings). Note that asserts
# check if these are empty. If they can be empty use an available `OKEmpty`
# version (or add the missing needed one(s)) to avoid triggering an assert.
#
# `#nameOKEmpty`: name (as string). Will use an "(unnamed)" default message if
# the string is null or empty. Otherwise see the description above.
#
# `#names`: A list of names (strings).
#
# `#lexeme` a token. The token's `lexeme` property is used.
#
# `#string`, `#string2`, `#string3`: strings (that aren't names).
# Note: as a rule of thumb, avoid using the `#string` keys. In particular,
# do not use them for composing error messages, see [diagnostics.md](
# lib/src/fasta/diagnostics.md#avoid-composing-messages-programmatically).
# Note that asserts check if these are empty. If they can be empty use an
# available `OKEmpty` version (or add the missing needed one(s)) to avoid
# triggering an assert.
#
# `#stringOKEmpty`: string (that isn't a name). Will use an "(empty)" default
# message if the string is null or empty.
# Otherwise see the description above.
#
# `#type`, #type2`, `#type3`: Kernel types.
#
# `#uri`, `#uri2`, `#uri3`: URIs.
#
# `#count`, `#count2`: counts (as integers)
#
# `#constant` a Kernel constant.
#
# `#num1%N.M`, `#num2%N.M`, `#num3%N.M`: numbers (doubles) formatted to minimum
# width N and with M fraction digits.
AsciiControlCharacter:
problemMessage: "The control character #unicode can only be used in strings and comments."
analyzerCode: ILLEGAL_CHARACTER
expression: "\x1b 1"
ConstEvalStartingPoint:
problemMessage: "Constant evaluation error:"
ConstEvalContext:
problemMessage: "While analyzing:"
ConstEvalDuplicateElement:
problemMessage: "The element '#constant' conflicts with another existing element in the set."
analyzerCode: EQUAL_ELEMENTS_IN_CONST_SET
ConstEvalDuplicateKey:
problemMessage: "The key '#constant' conflicts with another existing key in the map."
analyzerCode: EQUAL_KEYS_IN_CONST_MAP
ConstEvalElementImplementsEqual:
problemMessage: "The element '#constant' does not have a primitive operator '=='."
analyzerCode: CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS
ConstEvalElementNotPrimitiveEquality:
problemMessage: "The element '#constant' does not have a primitive equality."
ConstEvalKeyImplementsEqual:
problemMessage: "The key '#constant' does not have a primitive operator '=='."
analyzerCode: CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
ConstEvalKeyNotPrimitiveEquality:
problemMessage: "The key '#constant' does not have a primitive equality."
ConstEvalCaseImplementsEqual:
problemMessage: "Case expression '#constant' does not have a primitive operator '=='."
ConstEvalInvalidType:
problemMessage: "Expected constant '#constant' to be of type '#type', but was of type '#type2'."
ConstEvalInvalidBinaryOperandType:
problemMessage: "Binary operator '#stringOKEmpty' on '#constant' requires operand of type '#type', but was of type '#type2'."
ConstEvalInvalidEqualsOperandType:
problemMessage: "Binary operator '==' requires receiver constant '#constant' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type '#type'."
ConstEvalEqualsOperandNotPrimitiveEquality:
problemMessage: "Binary operator '==' requires receiver constant '#constant' of a type with primitive equality or type 'double', but was of type '#type'."
ConstEvalZeroDivisor:
problemMessage: "Binary operator '#string' on '#string2' requires non-zero divisor, but divisor was '0'."
analyzerCode: CONST_EVAL_THROWS_IDBZE
ConstEvalNegativeShift:
problemMessage: "Binary operator '#string' on '#string2' requires non-negative operand, but was '#string3'."
ConstEvalTruncateError:
problemMessage: "Binary operator '#string ~/ #string2' results is Infinity or NaN."
ConstEvalNonNull:
problemMessage: "Constant expression must be non-null."
ConstEvalGetterNotFound:
problemMessage: "Variable get not found: '#nameOKEmpty'"
ConstEvalInvalidMethodInvocation:
problemMessage: "The method '#stringOKEmpty' can't be invoked on '#constant' in a constant expression."
analyzerCode: UNDEFINED_OPERATOR
ConstEvalInvalidPropertyGet:
problemMessage: "The property '#stringOKEmpty' can't be accessed on '#constant' in a constant expression."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalInvalidRecordIndexGet:
problemMessage: "The property '#stringOKEmpty' can't be accessed on '#constant' in a constant expression."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalInvalidRecordNameGet:
problemMessage: "The property '#stringOKEmpty' can't be accessed on '#constant' in a constant expression."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalInvalidStringInterpolationOperand:
problemMessage: |
The constant value '#constant' 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.
analyzerCode: CONST_EVAL_TYPE_BOOL_NUM_STRING
ConstEvalInvalidStaticInvocation:
problemMessage: "The invocation of '#nameOKEmpty' is not allowed in a constant expression."
analyzerCode: CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
ConstEvalInvalidSymbolName:
problemMessage: "The symbol name must be a valid public Dart member name, public constructor name, or library name, optionally qualified, but was '#constant'."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalFailedAssertion:
problemMessage: "This assertion failed."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalFailedAssertionWithMessage:
problemMessage: "This assertion failed with message: #stringOKEmpty"
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalFailedAssertionWithNonStringMessage:
problemMessage: "This assertion failed with a non-String message."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalNonConstantVariableGet:
problemMessage: "The variable '#nameOKEmpty' is not a constant, only constant expressions are allowed."
analyzerCode: NON_CONSTANT_VALUE_IN_INITIALIZER
ConstEvalDeferredLibrary:
problemMessage: >
'#nameOKEmpty' can't be used in a constant expression because it's marked as
'deferred' which means it isn't available until loaded.
correctionMessage: >
Try moving the constant from the deferred library, or removing 'deferred'
from the import.
analyzerCode: INVALID_ANNOTATION_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY
ConstEvalFreeTypeParameter:
problemMessage: "The type '#type' is not a constant because it depends on a type parameter, only instantiated types are allowed."
ConstEvalCircularity:
problemMessage: "Constant expression depends on itself."
analyzerCode: RECURSIVE_COMPILE_TIME_CONSTANT
ConstEvalNullValue:
problemMessage: "Null value during constant evaluation."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalNotListOrSetInSpread:
problemMessage: "Only lists and sets can be used in spreads in constant lists and sets."
analyzerCode: CONST_SPREAD_EXPECTED_LIST_OR_SET
ConstEvalNotMapInSpread:
problemMessage: "Only maps can be used in spreads in constant maps."
analyzerCode: CONST_SPREAD_EXPECTED_MAP
ConstEvalExtension:
problemMessage: "Extension operations can't be used in constant expressions."
analyzerCode: NOT_CONSTANT_EXPRESSION
ConstEvalExternalConstructor:
problemMessage: "External constructors can't be evaluated in constant expressions."
ConstEvalExternalFactory:
problemMessage: "External factory constructors can't be evaluated in constant expressions."
ConstEvalUnevaluated:
problemMessage: "Couldn't evaluate constant expression."
ConstEvalError:
problemMessage: "Error evaluating constant expression: #string"
ConstEvalUnhandledCoreException:
problemMessage: "Unhandled core exception: #stringOKEmpty"
ConstEvalUnhandledException:
problemMessage: "Unhandled exception: #constant"
NotConstantExpression:
problemMessage: "#string is not a constant expression."
analyzerCode: NOT_CONSTANT_EXPRESSION
NotAConstantExpression:
problemMessage: "Not a constant expression."
analyzerCode: NOT_CONSTANT_EXPRESSION
MissingExplicitConst:
problemMessage: "Constant expression expected."
correctionMessage: "Try inserting 'const'."
analyzerCode: NOT_CONSTANT_EXPRESSION
script: >
class A {
final x;
const A(): x = [];
}
NonAsciiIdentifier:
problemMessage: "The non-ASCII character '#character' (#unicode) can't be used in identifiers, only in strings and comments."
correctionMessage: "Try using an US-ASCII letter, a digit, '_' (an underscore), or '$' (a dollar sign)."
analyzerCode: ILLEGAL_CHARACTER
expression: "å"
NonAsciiWhitespace:
problemMessage: "The non-ASCII space character #unicode can only be used in strings and comments."
analyzerCode: ILLEGAL_CHARACTER
expression: "\u2028 1"
Encoding:
problemMessage: "Unable to decode bytes as UTF-8."
bytes: [255]
ExperimentNotEnabled:
index: 48
problemMessage: "This requires the '#string' language feature to be enabled."
correctionMessage: "Try updating your pubspec.yaml to set the minimum SDK constraint to #string2 or higher, and running 'pub get'."
analyzerCode: ParserErrorCode.EXPERIMENT_NOT_ENABLED
ExperimentNotEnabledOffByDefault:
index: 133
problemMessage: "This requires the experimental '#string' language feature to be enabled."
correctionMessage: "Try passing the '--enable-experiment=#string' command line option."
analyzerCode: ParserErrorCode.EXPERIMENT_NOT_ENABLED_OFF_BY_DEFAULT
ExperimentDisabled:
problemMessage: "This requires the '#string' language feature to be enabled."
correctionMessage: "The feature is on by default but is currently disabled, maybe because the '--enable-experiment=no-#string' command line option is passed."
analyzerCode: ParserErrorCode.EXPERIMENT_NOT_ENABLED
ExperimentDisabledInvalidLanguageVersion:
problemMessage: "This requires the '#string' language feature, which requires language version of #string2 or higher."
analyzerCode: ParserErrorCode.EXPERIMENT_NOT_ENABLED
EmptyNamedParameterList:
problemMessage: "Named parameter lists cannot be empty."
correctionMessage: "Try adding a named parameter to the list."
analyzerCode: "MISSING_IDENTIFIER"
script: >
foo({}) {}
main() {
foo();
}
RecordLiteralOnePositionalFieldNoTrailingComma:
problemMessage: "A record literal with exactly one positional field requires a trailing comma."
correctionMessage: "Try adding a trailing comma."
analyzerCode: ParserErrorCode.RECORD_LITERAL_ONE_POSITIONAL_NO_TRAILING_COMMA
index: 127
hasPublishedDocs: true
documentation: |-
#### Description
The analyzer produces this diagnostic when a record literal with a single
positional field doesn't have a trailing comma after the field.
In some locations a record literal with a single positional field could
also be a parenthesized expression. A trailing comma is required to
disambiguate these two valid interpretations.
#### Example
The following code produces this diagnostic because the record literal has
one positional field but doesn't have a trailing comma:
```dart
var r = const (1[!)!];
```
#### Common fixes
Add a trailing comma:
```dart
var r = const (1,);
```
script: >
main() {
var record = const (1);
}
RecordLiteralZeroFieldsWithTrailingComma:
problemMessage: "A record literal without fields can't have a trailing comma."
correctionMessage: "Try removing the trailing comma."
analyzerCode: ParserErrorCode.EMPTY_RECORD_LITERAL_WITH_COMMA
index: 128
hasPublishedDocs: true
documentation: |-
#### Description
The analyzer produces this diagnostic when a record literal that has no
fields has a trailing comma. Empty record literals can't contain a comma.
#### Example
The following code produces this diagnostic because the empty record
literal has a trailing comma:
```dart
var r = ([!,!]);
```
#### Common fixes
If the record is intended to be empty, then remove the comma:
```dart
var r = ();
```
If the record is intended to have one or more fields, then add the
expressions used to compute the values of those fields:
```dart
var r = (3, 4);
```
script: >
main() {
var record = (,);
}
EmptyRecordTypeNamedFieldsList:
problemMessage: "The list of named fields in a record type can't be empty."
correctionMessage: "Try adding a named field to the list."
analyzerCode: ParserErrorCode.EMPTY_RECORD_TYPE_NAMED_FIELDS_LIST
index: 129
hasPublishedDocs: true
documentation: |-
#### Description
The analyzer produces this diagnostic when a record type has an empty list
of named fields.
#### Example
The following code produces this diagnostic because the record type has an
empty list of named fields:
```dart
void f((int, int, {[!}!]) r) {}
```
#### Common fixes
If the record is intended to have named fields, then add the types and
names of the fields:
```dart
void f((int, int, {int z}) r) {}
```
If the record isn't intended to have named fields, then remove the curly
braces:
```dart
void f((int, int) r) {}
```
script: >
main() {
(int, int, {/*missing*/}) record = (1, 2,);
}
RecordTypeZeroFieldsButTrailingComma:
problemMessage: "A record type without fields can't have a trailing comma."
correctionMessage: "Try removing the trailing comma."
analyzerCode: ParserErrorCode.EMPTY_RECORD_TYPE_WITH_COMMA
index: 130
hasPublishedDocs: true
documentation: |-
#### Description
The analyzer produces this diagnostic when a record type that has no
fields has a trailing comma. Empty record types can't contain a comma.
#### Example
The following code produces this diagnostic because the empty record type
has a trailing comma:
```dart
void f(([!,!]) r) {}
```
#### Common fixes
If the record type is intended to be empty, then remove the comma:
```dart
void f(() r) {}
```
If the record type is intended to have one or more fields, then add the
types of those fields:
```dart
void f((int, int) r) {}
```
script: >
main() {
(,) record = ();
}
RecordTypeOnePositionalFieldNoTrailingComma:
problemMessage: "A record type with exactly one positional field requires a trailing comma."
correctionMessage: "Try adding a trailing comma."
analyzerCode: ParserErrorCode.RECORD_TYPE_ONE_POSITIONAL_NO_TRAILING_COMMA
index: 131
hasPublishedDocs: true
documentation: |-
#### Description
The analyzer produces this diagnostic when a record type annotation with a
single positional field doesn't have a trailing comma after the field.
In some locations a record type with a single positional field could also
be a parenthesized expression. A trailing comma is required to
disambiguate these two valid interpretations.
#### Example
The following code produces this diagnostic because the record type has
one positional field, but doesn't have a trailing comma:
```dart
void f((int[!)!] r) {}
```
#### Common fixes
Add a trailing comma:
```dart
void f((int,) r) {}
```
script: >
main() {
(int /* missing trailing comma */) record = const (1, );
}
DuplicatedRecordTypeFieldName:
problemMessage: "Duplicated record type field name '#name'."
correctionMessage: "Try renaming or removing one of the named record type fields."
script: |
({int a, String a}) record = throw '';
DuplicatedRecordTypeFieldNameContext:
problemMessage: "This is the existing record type field named '#name'."
severity: CONTEXT
DuplicatedRecordLiteralFieldName:
problemMessage: "Duplicated record literal field name '#name'."
correctionMessage: "Try renaming or removing one of the named record literal fields."
script: |
dynamic field = (a: 0, a: 1);
DuplicatedRecordLiteralFieldNameContext:
problemMessage: "This is the existing record literal field named '#name'."
severity: CONTEXT
EmptyOptionalParameterList:
problemMessage: "Optional parameter lists cannot be empty."
correctionMessage: "Try adding an optional parameter to the list."
analyzerCode: "MISSING_IDENTIFIER"
script: >
foo([]) {}
main() {
foo();
}
ExpectedElseOrComma:
index: 46
problemMessage: "Expected 'else' or comma."
analyzerCode: ParserErrorCode.EXPECTED_ELSE_OR_COMMA
ExpectedBlock:
problemMessage: "Expected a block."
correctionMessage: "Try adding {}."
analyzerCode: EXPECTED_TOKEN
script: "try finally {}"
ExpectedBlockToSkip:
problemMessage: "Expected a function body or '=>'."
# TODO(ahe): In some scenarios, we can suggest removing the 'static' keyword.
correctionMessage: "Try adding {}."
analyzerCode: MISSING_FUNCTION_BODY
script: "main();"
ExpectedBody:
problemMessage: "Expected a function body or '=>'."
# TODO(ahe): In some scenarios, we can suggest removing the 'static' keyword.
correctionMessage: "Try adding {}."
analyzerCode: MISSING_FUNCTION_BODY
script: "main();"
ExpectedStatement:
index: 29
problemMessage: "Expected a statement."
analyzerCode: ParserErrorCode.MISSING_STATEMENT
statement: "void;"
ExpectedButGot:
# Also see ExpectedAfterButGot and ExpectedInstead
problemMessage: "Expected '#string' before this."
# Consider the second example below: the parser expects a ')' before 'y', but
# a ',' would also have worked. We don't have enough information to give a
# good suggestion.
analyzerCode: EXPECTED_TOKEN
script:
- "main() => true ? 1;"
- "main() => foo(x: 1 y: 2);"
ExpectedAfterButGot:
# Also see ExpectedButGot and ExpectedInstead
problemMessage: "Expected '#string' after this."
# This is an alternative to ExpectedButGot when it's better for the error to be
# associated with the last consumed token rather than the token being parsed.
# Doing so can make it cognitively easier for the user to understand and fix.
#
# For example, this is ok...
#
# x = 7
# class Foo {
# ^^^^^
# Expected ';' before this
#
# but this is easier for the user...
#
# x = 7
# ^
# Expected ';' after this
# class Foo {
#
analyzerCode: EXPECTED_TOKEN
script:
- "main() { return true }"
ExpectedInstead:
# Also see ExpectedButGot and ExpectedAfterButGot
index: 41
problemMessage: "Expected '#string' instead of this."
# This is an alternative to ExpectedButGot when the last consumed token
# should be replaced with a different token.
#
# For example, this is ok...
#
# mixin Foo extends Bar {
# ^^^^^^^
# Expected 'on' before this
#
# but this is easier for the user...
#
# mixin Foo extends Bar {
# ^^^^^^^
# Expected 'on' instead of this
#
analyzerCode: ParserErrorCode.EXPECTED_INSTEAD
script:
- "class B {} mixin A extends B { }"
MultipleLibraryDirectives:
index: 27
problemMessage: "Only one library directive may be declared in a file."
correctionMessage: "Try removing all but one of the library directives."
analyzerCode: ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES
MultipleExtends:
index: 28
problemMessage: "Each class definition can have at most one extends clause."
correctionMessage: "Try choosing one superclass and define your class to implement (or mix in) the others."
analyzerCode: ParserErrorCode.MULTIPLE_EXTENDS_CLAUSES
script:
- "class B{} class C{} class A extends B extends C {}"
- "class B{} class C{} class A extends B, C {}"
MultipleWith:
index: 24
problemMessage: "Each class definition can have at most one with clause."
correctionMessage: "Try combining all of the with clauses into a single clause."
analyzerCode: ParserErrorCode.MULTIPLE_WITH_CLAUSES
script: "class A extends B with C, D with E {}"
WithBeforeExtends:
index: 11
problemMessage: "The extends clause must be before the with clause."
correctionMessage: "Try moving the extends clause before the with clause."
analyzerCode: ParserErrorCode.WITH_BEFORE_EXTENDS
script: "mixin B {} class C {} class A with B extends C {}"
ImplementsBeforeExtends:
index: 44
problemMessage: "The extends clause must be before the implements clause."
correctionMessage: "Try moving the extends clause before the implements clause."
analyzerCode: ParserErrorCode.IMPLEMENTS_BEFORE_EXTENDS
script: "class A implements B extends C {}"
ImplementsBeforeOn:
index: 43
problemMessage: "The on clause must be before the implements clause."
correctionMessage: "Try moving the on clause before the implements clause."
analyzerCode: ParserErrorCode.IMPLEMENTS_BEFORE_ON
script: "mixin A implements B on C {}"
ImplementsBeforeWith:
index: 42
problemMessage: "The with clause must be before the implements clause."
correctionMessage: "Try moving the with clause before the implements clause."
analyzerCode: ParserErrorCode.IMPLEMENTS_BEFORE_WITH
script: "class A extends B implements C with D {}"
ImplementsRepeated:
problemMessage: "'#name' can only be implemented once."
analyzerCode: IMPLEMENTS_REPEATED
correctionMessage: "Try removing #count of the occurrences."
script:
- >-
abstract class I {}
abstract class J {}
class K implements I, J, I {}
ImplementsSuperClass:
problemMessage: "'#name' can't be used in both 'extends' and 'implements' clauses."
analyzerCode: IMPLEMENTS_SUPER_CLASS
correctionMessage: "Try removing one of the occurrences."
script:
- >-
abstract class A {}
class C extends A implements A {}
MultipleImplements:
problemMessage: "Each class definition can have at most one implements clause."
correctionMessage: "Try combining all of the implements clauses into a single clause."
analyzerCode: MULTIPLE_IMPLEMENTS_CLAUSES
script: "class A implements B implements C, D {}"
MultipleClauses:
problemMessage: "Each '#string' definition can have at most one '#string2' clause."
correctionMessage: "Try combining all of the '#string2' clauses into a single clause."
analyzerCode: ParserErrorCode.MULTIPLE_CLAUSES
index: 121
script:
- "mixin B {} enum A implements B implements C, D { v; }"
- "mixin B {} enum A with B with C, D { v; }"
OutOfOrderClauses:
problemMessage: "The '#string' clause must come before the '#string2' clause."
correctionMessage: "Try moving the '#string' clause before the '#string2' clause."
analyzerCode: ParserErrorCode.OUT_OF_ORDER_CLAUSES
index: 122
script: "class B {} class D {} enum A implements B with D { v; }"
MultipleOnClauses:
index: 26
problemMessage: "Each mixin definition can have at most one on clause."
correctionMessage: "Try combining all of the on clauses into a single clause."
analyzerCode: ParserErrorCode.MULTIPLE_ON_CLAUSES
script: "mixin A on B on C, D {}"
MixinWithClause:
index: 154
problemMessage: "A mixin can't have a with clause."
analyzerCode: ParserErrorCode.MIXIN_WITH_CLAUSE
script: "mixin M {} mixin N with M {}"
ExtendsFutureOr:
problemMessage: "The type 'FutureOr' can't be used in an 'extends' clause."
ImplementsFutureOr:
problemMessage: "The type 'FutureOr' can't be used in an 'implements' clause."
ExtendsNever:
problemMessage: "The type 'Never' can't be used in an 'extends' clause."
ImplementsNever:
problemMessage: "The type 'Never' can't be used in an 'implements' clause."
ExtendsVoid:
problemMessage: "The type 'void' can't be used in an 'extends' clause."
ImplementsVoid:
problemMessage: "The type 'void' can't be used in an 'implements' clause."
ExpectedClassBody:
index: 8
problemMessage: "A class declaration must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_CLASS_BODY
sharedName: EXPECTED_BODY
script: |
class Class
ExpectedMixinBody:
index: 166
problemMessage: "A mixin declaration must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_MIXIN_BODY
sharedName: EXPECTED_BODY
script: |
mixin Mixin
ExpectedExtensionBody:
index: 173
problemMessage: "An extension declaration must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_EXTENSION_BODY
sharedName: EXPECTED_BODY
script: |
extension Extension on int
ExpectedExtensionTypeBody:
index: 167
problemMessage: "An extension type declaration must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_EXTENSION_TYPE_BODY
sharedName: EXPECTED_BODY
script: |
extension type ExtensionType(int i)
ExpectedTryStatementBody:
index: 168
problemMessage: "A try statement must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_TRY_STATEMENT_BODY
sharedName: EXPECTED_BODY
script: |
method() {
try finally {}
}
ExpectedCatchClauseBody:
index: 169
problemMessage: "A catch clause must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_CATCH_CLAUSE_BODY
sharedName: EXPECTED_BODY
script: |
method() {
try {} catch (_);
}
ExpectedFinallyClauseBody:
index: 170
problemMessage: "A finally clause must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_FINALLY_CLAUSE_BODY
sharedName: EXPECTED_BODY
script: |
method() {
try {} finally;
}
ExpectedSwitchExpressionBody:
index: 171
problemMessage: "A switch expression must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_SWITCH_EXPRESSION_BODY
sharedName: EXPECTED_BODY
script: |
method(Never n) => switch (n);
ExpectedSwitchStatementBody:
index: 172
problemMessage: "A switch statement must have a body, even if it is empty."
correctionMessage: "Try adding an empty body."
analyzerCode: ParserErrorCode.EXPECTED_SWITCH_STATEMENT_BODY
sharedName: EXPECTED_BODY
script: |
method(Never n) {
switch (n);
}
ExpectedDeclaration:
problemMessage: "Expected a declaration, but got '#lexeme'."
analyzerCode: EXPECTED_EXECUTABLE
ExpectedClassMember:
problemMessage: "Expected a class member, but got '#lexeme'."
analyzerCode: EXPECTED_CLASS_MEMBER
ExpectedFunctionBody:
problemMessage: "Expected a function body, but got '#lexeme'."
analyzerCode: MISSING_FUNCTION_BODY
ExpectedHexDigit:
problemMessage: "A hex digit (0-9 or A-F) must follow '0x'."
# No tip, seems obvious from the error message.
analyzerCode: MISSING_HEX_DIGIT
script: >
main() {
var i = 0x;
}
ExpectedIdentifier:
problemMessage: "Expected an identifier, but got '#lexeme'."
correctionMessage: "Try inserting an identifier before '#lexeme'."
analyzerCode: MISSING_IDENTIFIER
script: "var = 42;"
ExpectedIdentifierButGotKeyword:
problemMessage: "'#lexeme' can't be used as an identifier because it's a keyword."
correctionMessage: "Try renaming this to be an identifier that isn't a keyword."
index: 113
analyzerCode: ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD
script: "var default = 42;"
EqualityCannotBeEqualityOperand:
index: 1
problemMessage: "A comparison expression can't be an operand of another comparison expression."
correctionMessage: "Try putting parentheses around one of the comparisons."
analyzerCode: ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
script:
- "main() { var b = a < b < c; }"
- "main() { var b = a == b != c; }"
ExpectedOpenParens:
problemMessage: "Expected '('."
ExpectedString:
problemMessage: "Expected a String, but got '#lexeme'."
analyzerCode: EXPECTED_STRING_LITERAL
ExpectedToken:
problemMessage: "Expected to find '#string'."
analyzerCode: EXPECTED_TOKEN
ExpectedType:
problemMessage: "Expected a type, but got '#lexeme'."
analyzerCode: EXPECTED_TYPE_NAME
VarAsTypeName:
index: 61
problemMessage: "The keyword 'var' can't be used as a type name."
analyzerCode: ParserErrorCode.VAR_AS_TYPE_NAME
script:
- "class A { Map<String, var> m; }"
MissingExpressionInThrow:
index: 32
problemMessage: "Missing expression after 'throw'."
correctionMessage: "Add an expression after 'throw' or use 'rethrow' to throw a caught exception"
analyzerCode: ParserErrorCode.MISSING_EXPRESSION_IN_THROW
statement:
- "throw;"
MissingConstFinalVarOrType:
index: 33
problemMessage: "Variables must be declared using the keywords 'const', 'final', 'var' or a type name."
correctionMessage: "Try adding the name of the type of the variable or the keyword 'var'."
analyzerCode: ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
script:
- "class C { static f; }"
FunctionTypedParameterVar:
index: 119
problemMessage: "Function-typed parameters can't specify 'const', 'final' or 'var' in place of a return type."
correctionMessage: "Try replacing the keyword with a return type."
analyzerCode: ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR
script:
- "void f(const x()) {}"
- "void f(final x()) {}"
- "void f(var x()) {}"
AbstractClassMember:
index: 51
problemMessage: "Members of classes can't be declared to be 'abstract'."
correctionMessage: "Try removing the 'abstract' keyword. You can add the 'abstract' keyword before the class declaration."
analyzerCode: ParserErrorCode.ABSTRACT_CLASS_MEMBER
configuration: nnbd-weak
script:
- |
abstract class C {abstract C.c();}
- |
abstract class C {abstract m();}
- |
abstract class C {abstract get m;}
- |
abstract class C {abstract set m(int x);}
AbstractExternalField:
index: 110
problemMessage: "Fields can't be declared both 'abstract' and 'external'."
analyzerCode: ParserErrorCode.ABSTRACT_EXTERNAL_FIELD
correctionMessage: "Try removing the 'abstract' or 'external' keyword."
script:
- "abstract class C {abstract external var f;}"
- "abstract class C {external abstract var f;}"
AbstractStaticField:
index: 107
problemMessage: "Static fields can't be declared 'abstract'."
analyzerCode: ParserErrorCode.ABSTRACT_STATIC_FIELD
correctionMessage: "Try removing the 'abstract' or 'static' keyword."
script:
- "abstract class C {abstract static var f;}"
AbstractExtensionField:
problemMessage: "Extension fields can't be declared 'abstract'."
correctionMessage: "Try removing the 'abstract' keyword."
analyzerCode: ABSTRACT_EXTENSION_FIELD
exampleAllowMoreCodes: true
script:
- "extension C on int {abstract static var f;}"
AbstractFieldInitializer:
problemMessage: "Abstract fields cannot have initializers."
correctionMessage: "Try removing the initializer or the 'abstract' keyword."
script:
- "abstract class C {abstract var f = 0;}"
AbstractFieldConstructorInitializer:
problemMessage: "Abstract fields cannot have initializers."
correctionMessage: "Try removing the field initializer or the 'abstract' keyword from the field declaration."
script:
- "abstract class C {abstract var f; C(this.f);}"
- "abstract class C {abstract var f; C() : this.f = 0;}"
AbstractLateField:
index: 108
problemMessage: "Abstract fields cannot be late."
analyzerCode: ParserErrorCode.ABSTRACT_LATE_FIELD
correctionMessage: "Try removing the 'abstract' or 'late' keyword."
script:
- "abstract class C {abstract late var f;}"
AbstractFinalBaseClass:
problemMessage: "An 'abstract' class can't be declared as both 'final' and 'base'."
correctionMessage: "Try removing either the 'final' or 'base' keyword."
analyzerCode: ParserErrorCode.ABSTRACT_FINAL_BASE_CLASS
index: 176
script:
- "abstract final base class C {}"
AbstractFinalInterfaceClass:
problemMessage: "An 'abstract' class can't be declared as both 'final' and 'interface'."
correctionMessage: "Try removing either the 'final' or 'interface' keyword."
analyzerCode: ParserErrorCode.ABSTRACT_FINAL_INTERFACE_CLASS
index: 177
script:
- "abstract final interface class C {}"
AbstractSealedClass:
problemMessage: "A 'sealed' class can't be marked 'abstract' because it's already implicitly abstract."
correctionMessage: "Try removing the 'abstract' keyword."
analyzerCode: ParserErrorCode.ABSTRACT_SEALED_CLASS
index: 132
hasPublishedDocs: true
documentation: |-
#### Description
The analyzer produces this diagnostic when a class is declared using both
the modifier `abstract` and the modifier `sealed`. Sealed classes are
implicitly abstract, so explicitly using both modifiers is not allowed.
#### Example
The following code produces this diagnostic because the class `C` is
declared using both `abstract` and `sealed`:
```dart
abstract [!sealed!] class C {}
```
#### Common fixes
If the class should be abstract but not sealed, then remove the `sealed`
modifier:
```dart
abstract class C {}
```
If the class should be both abstract and sealed, then remove the
`abstract` modifier:
```dart
sealed class C {}
```
script:
- "sealed abstract class C {}"
- "abstract sealed class C {}"
ClassInClass:
index: 53
problemMessage: "Classes can't be declared inside other classes."
correctionMessage: "Try moving the class to the top-level."
analyzerCode: ParserErrorCode.CLASS_IN_CLASS
script:
- "class C { class B {} }"
EnumInClass:
index: 74
problemMessage: "Enums can't be declared inside classes."
correctionMessage: "Try moving the enum to the top-level."
analyzerCode: ParserErrorCode.ENUM_IN_CLASS
script:
- "class Foo { enum Bar { Bar1, Bar2, Bar3 } }"
TypedefInClass:
index: 7
problemMessage: "Typedefs can't be declared inside classes."
correctionMessage: "Try moving the typedef to the top-level."
analyzerCode: ParserErrorCode.TYPEDEF_IN_CLASS
script:
- "abstract class C { typedef int F(int x); }"
CovariantMember:
index: 67
problemMessage: "Getters, setters and methods can't be declared to be 'covariant'."
correctionMessage: "Try removing the 'covariant' keyword."
analyzerCode: ParserErrorCode.COVARIANT_MEMBER
script:
- "static covariant get x => 0;"
- "covariant int m() => 0;"
VarReturnType:
index: 12
problemMessage: "The return type can't be 'var'."
correctionMessage: "Try removing the keyword 'var', or replacing it with the name of the return type."
analyzerCode: ParserErrorCode.VAR_RETURN_TYPE
script:
- "class C { var m() {} }"
- "class C { var C() {} }"
ConstClass:
index: 60
problemMessage: "Classes can't be declared to be 'const'."
correctionMessage: "Try removing the 'const' keyword. If you're trying to indicate that instances of the class can be constants, place the 'const' keyword on the class' constructor(s)."
analyzerCode: ParserErrorCode.CONST_CLASS
script: "const class C {}"
ConstAndFinal:
index: 58
problemMessage: "Members can't be declared to be both 'const' and 'final'."
correctionMessage: "Try removing either the 'const' or 'final' keyword."
analyzerCode: ParserErrorCode.CONST_AND_FINAL
declaration:
- "class C { static const final int x = 5; }"
- "class C { static final const int x = 5; }"
- "const final int x = 5;"
- "final const int x = 5;"
ConflictingModifiers:
index: 59
problemMessage: "Members can't be declared to be both '#string' and '#string2'."
correctionMessage: "Try removing one of the keywords."
analyzerCode: ParserErrorCode.CONFLICTING_MODIFIERS
script:
- "class C { const var x; }"
- "class C { var const x; }"
ConstFactory:
index: 62
problemMessage: "Only redirecting factory constructors can be declared to be 'const'."
correctionMessage: "Try removing the 'const' keyword, or replacing the body with '=' followed by a valid target."
analyzerCode: ParserErrorCode.CONST_FACTORY
script: |
class C {
const factory C() => const C.internal();
const C.internal();
}
ConstFactoryRedirectionToNonConst:
problemMessage: "Constant factory constructor can't delegate to a non-constant constructor."
correctionMessage: "Try redirecting to a different constructor or marking the target constructor 'const'."
analyzerCode: REDIRECT_TO_NON_CONST_CONSTRUCTOR
script:
- >-
class A {
const factory A.foo() = A.bar;
A.bar() {}
}
NonConstFactory:
problemMessage: "Cannot invoke a non-'const' factory where a const expression is expected."
correctionMessage: "Try using a constructor or factory that is 'const'."
analyzerCode: NOT_CONSTANT_EXPRESSION
NonConstConstructor:
problemMessage: "Cannot invoke a non-'const' constructor where a const expression is expected."
correctionMessage: "Try using a constructor or factory that is 'const'."
analyzerCode: NOT_CONSTANT_EXPRESSION
ModifierOutOfOrder:
index: 56
problemMessage: "The modifier '#string' should be before the modifier '#string2'."
correctionMessage: "Try re-ordering the modifiers."
analyzerCode: ParserErrorCode.MODIFIER_OUT_OF_ORDER
script:
- "class C { factory const C() = prefix.B.foo; }"
- "class C { factory external C(); }"
- "class C { const external C(); }"
- "class C { static external f(); }"
- "class C { final static int f = 5; }"
- "class C { var static f; }"
TypeBeforeFactory:
index: 57
problemMessage: "Factory constructors cannot have a return type."
correctionMessage: "Try removing the type appearing before 'factory'."
analyzerCode: ParserErrorCode.TYPE_BEFORE_FACTORY
script: |
class C {
T factory C() { return new C.constructor(); }
C.constructor();
}
ConstConstructorWithBody:
problemMessage: "A const constructor can't have a body."
correctionMessage: "Try removing either the 'const' keyword or the body."
analyzerCode: CONST_CONSTRUCTOR_WITH_BODY
script:
- "class C { const C() {} }"
ConstMethod:
index: 63
problemMessage: "Getters, setters and methods can't be declared to be 'const'."
correctionMessage: "Try removing the 'const' keyword."
analyzerCode: ParserErrorCode.CONST_METHOD
script:
- "class C { const m() {} }"
CovariantAndStatic:
index: 66
problemMessage: "Members can't be declared to be both 'covariant' and 'static'."
correctionMessage: "Try removing either the 'covariant' or 'static' keyword."
analyzerCode: ParserErrorCode.COVARIANT_AND_STATIC
script:
- "class C { covariant static A f; }"
- "class C { static covariant A f; }"
DuplicatedModifier:
index: 70
problemMessage: "The modifier '#lexeme' was already specified."
correctionMessage: "Try removing all but one occurrence of the modifier."
analyzerCode: ParserErrorCode.DUPLICATED_MODIFIER
comment: |-
Parameters:
0: the modifier that was duplicated
script:
- "class C { const const m; }"
- "class C { external external f(); }"
- "class C { final final m = 5; }"
- "class C { static static var m; }"
- "class C { var var m; }"
ExternalConstructorWithBody:
index: 87
problemMessage: "External constructors can't have a body."
correctionMessage: "Try removing the body of the constructor, or removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_BODY
script:
- "class C { external C() {} }"
ExternalConstructorWithFieldInitializers:
index: 178
problemMessage: "An external constructor can't initialize fields."
correctionMessage: "Try removing the field initializers, or removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_FIELD_INITIALIZERS
ExternalFactoryWithBody:
index: 86
problemMessage: "External factories can't have a body."
correctionMessage: "Try removing the body of the factory, or removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_FACTORY_WITH_BODY
script:
- "class C { external factory C() {} }"
ExternalField:
index: 50
problemMessage: "Fields can't be declared to be 'external'."
correctionMessage: "Try removing the keyword 'external', or replacing the field by an external getter and/or setter."
analyzerCode: ParserErrorCode.EXTERNAL_FIELD
configuration: nnbd-weak
ExternalFieldInitializer:
problemMessage: "External fields cannot have initializers."
correctionMessage: "Try removing the initializer or the 'external' keyword."
script:
- "external var f = 0;"
- "abstract class C {external var f = 0;}"
ExternalFieldConstructorInitializer:
problemMessage: "External fields cannot have initializers."
correctionMessage: "Try removing the field initializer or the 'external' keyword from the field declaration."
script:
- "abstract class C {external var f; C(this.f);}"
- "abstract class C {external var f; C() : this.f = 0;}"
ExternalLateField:
index: 109
problemMessage: "External fields cannot be late."
analyzerCode: ParserErrorCode.EXTERNAL_LATE_FIELD
correctionMessage: "Try removing the 'external' or 'late' keyword."
script:
- "external late var f;"
- "abstract class C {external late var f;}"
InitializerForStaticField:
problemMessage: "'#name' isn't an instance field of this class."
analyzerCode: INITIALIZER_FOR_STATIC_FIELD
MoreThanOneSuperInitializer:
problemMessage: "Can't have more than one 'super' initializer."
analyzerCode: MULTIPLE_SUPER_INITIALIZERS
script:
- "class C { C.bad() : super(), super(); }"
RedirectingConstructorWithSuperInitializer:
problemMessage: "A redirecting constructor can't have a 'super' initializer."
analyzerCode: SUPER_IN_REDIRECTING_CONSTRUCTOR
script:
- "class C { C(); C.bad() : super(), this(); }"
- "class C { C(); C.bad() : this(), super(); }"
RedirectingConstructorWithMultipleRedirectInitializers:
problemMessage: "A redirecting constructor can't have more than one redirection."
analyzerCode: MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS
script:
- "class C { C(); C.bad() : this(), this(); }"
RedirectingConstructorWithAnotherInitializer:
problemMessage: "A redirecting constructor can't have other initializers."
# also ASSERT_IN_REDIRECTING_CONSTRUCTOR
analyzerCode: FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
script:
- "class C { int? x; C(); C.bad() : x = 5, this(); }"
- "class C { int? x; C(); C.bad() : this(), x = 5; }"
- "class C { int? x; C(); C.bad() : assert(true), this(); }"
- "class C { int? x; C(); C.bad() : this(), assert(true); }"
SuperInitializerNotLast:
problemMessage: "Can't have initializers after 'super'."
analyzerCode: SUPER_INVOCATION_NOT_LAST
script:
- "class C { int x; C.bad() : super(), x = 5; }"
ExtraneousModifier:
index: 77
problemMessage: "Can't have modifier '#lexeme' here."
correctionMessage: "Try removing '#lexeme'."
analyzerCode: ParserErrorCode.EXTRANEOUS_MODIFIER
script:
- "var String foo; main(){}"
- "var set foo; main(){}"
- "var final foo; main(){}"
- "var var foo; main(){}"
- "var const foo; main(){}"
- "var abstract foo; main(){}"
- "var static foo; main(){}"
- "var external foo; main(){}"
- "get var foo; main(){}"
- "set var foo; main(){}"
- "final var foo; main(){}"
- "var var foo; main(){}"
- "const var foo; main(){}"
- "abstract var foo; main(){}"
- "static var foo; main(){}"
- "external var foo; main(){}"
- "set foo; main(){}"
- "abstract foo; main(){}"
- "static foo; main(){}"
- "external foo; main(){}"
- "abstract enum foo {bar}"
- "abstract void foo() {}"
- "static void foo() {}"
- "abstract typedef foo();"
- "static typedef foo();"
ExtraneousModifierInExtension:
index: 98
problemMessage: "Can't have modifier '#lexeme' in an extension."
correctionMessage: "Try removing '#lexeme'."
analyzerCode: ParserErrorCode.INVALID_USE_OF_COVARIANT_IN_EXTENSION
hasPublishedDocs: true
comment: No parameters.
documentation: |-
#### Description
The analyzer produces this diagnostic when a member declared inside an
extension uses the keyword `covariant` in the declaration of a parameter.
Extensions aren't classes and don't have subclasses, so the keyword serves
no purpose.
#### Example
The following code produces this diagnostic because `i` is marked as being
covariant:
```dart
extension E on String {
void a([!covariant!] int i) {}
}
```
#### Common fixes
Remove the `covariant` keyword:
```dart
extension E on String {
void a(int i) {}
}
```
script:
- "extension on String { foo(covariant String child) {} }"
ExtraneousModifierInExtensionType:
index: 174
problemMessage: "Can't have modifier '#lexeme' in an extension type."
correctionMessage: "Try removing '#lexeme'."
analyzerCode: ParserErrorCode.EXTRANEOUS_MODIFIER_IN_EXTENSION_TYPE
script:
- "extension type ET(String i) { foo(covariant String child) {} }"
ExtraneousModifierInPrimaryConstructor:
index: 175
problemMessage: "Can't have modifier '#lexeme' in a primary constructor."
correctionMessage: "Try removing '#lexeme'."
analyzerCode: ParserErrorCode.EXTRANEOUS_MODIFIER_IN_PRIMARY_CONSTRUCTOR
script:
- "extension type ET(covariant String i) { }"
FinalAndCovariant:
index: 80
problemMessage: "Members can't be declared to be both 'final' and 'covariant'."
correctionMessage: "Try removing either the 'final' or 'covariant' keyword."
analyzerCode: ParserErrorCode.FINAL_AND_COVARIANT
script:
- "class C { covariant final f = 5; }"
- "class C { final covariant f = 5; }"
FinalAndCovariantLateWithInitializer:
index: 101
problemMessage: "Members marked 'late' with an initializer can't be declared to be both 'final' and 'covariant'."
correctionMessage: "Try removing either the 'final' or 'covariant' keyword, or removing the initializer."
analyzerCode: ParserErrorCode.FINAL_AND_COVARIANT_LATE_WITH_INITIALIZER
# Weak and strong doesn't matter in this instance.
script:
- "class C { covariant late final f = 5; }"
FinalAndVar:
index: 81
problemMessage: "Members can't be declared to be both 'final' and 'var'."
correctionMessage: "Try removing the keyword 'var'."
analyzerCode: ParserErrorCode.FINAL_AND_VAR
script:
- "class C { final var x = 5; }"
- "class C { var final x = 5; }"
StaticConstructor:
index: 4
problemMessage: "Constructors can't be static."
correctionMessage: "Try removing the keyword 'static'."
analyzerCode: ParserErrorCode.STATIC_CONSTRUCTOR
script:
- "class C { static C() {} }"
- "class C { static C.m() {} }"
GetterConstructor:
index: 103
problemMessage: "Constructors can't be a getter."
correctionMessage: "Try removing 'get'."
analyzerCode: ParserErrorCode.GETTER_CONSTRUCTOR
script:
- "class C { get C.m() {} }"
SetterConstructor:
index: 104
problemMessage: "Constructors can't be a setter."
correctionMessage: "Try removing 'set'."
analyzerCode: ParserErrorCode.SETTER_CONSTRUCTOR
script:
- "class C { set C.m(x) {} }"
StaticOperator:
index: 17
problemMessage: "Operators can't be static."
correctionMessage: "Try removing the keyword 'static'."
analyzerCode: ParserErrorCode.STATIC_OPERATOR
script:
- "class C { static operator +(int x) => x + 1; }"
BreakOutsideOfLoop:
index: 52
problemMessage: "A break statement can't be used outside of a loop or switch statement."
correctionMessage: "Try removing the break statement."
analyzerCode: ParserErrorCode.BREAK_OUTSIDE_OF_LOOP
script:
- "main() { break; }"
InvalidBreakTarget:
problemMessage: "Can't break to '#name'."
BreakTargetOutsideFunction:
problemMessage: "Can't break to '#name' in a different function."
analyzerCode: LABEL_IN_OUTER_SCOPE
statement: |
label: while (true) {
void f() {
while (true) {
break label;
}
}
}
AnonymousBreakTargetOutsideFunction:
problemMessage: "Can't break to a target in a different function."
analyzerCode: LABEL_IN_OUTER_SCOPE
statement: |
while (true) {
void f() {
break;
}
}
ContinueLabelInvalid:
problemMessage: "A 'continue' label must be on a loop or a switch member."
analyzerCode: CONTINUE_LABEL_INVALID
statement:
- "L: { for (var i in [ ]) { continue L; } }"
ContinueOutsideOfLoop:
index: 2
problemMessage: "A continue statement can't be used outside of a loop or switch statement."
correctionMessage: "Try removing the continue statement."
analyzerCode: ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP
script:
- "main() { continue; }"
InvalidContinueTarget:
problemMessage: "Can't continue at '#name'."
ContinueTargetOutsideFunction:
problemMessage: "Can't continue at '#name' in a different function."
analyzerCode: LABEL_IN_OUTER_SCOPE
statement: |
label: while (true) {
void f() {
while (true) {
continue label;
}
}
}
AnonymousContinueTargetOutsideFunction:
problemMessage: "Can't continue at a target in a different function."
analyzerCode: LABEL_IN_OUTER_SCOPE
statement: |
while (true) {
void f() {
continue;
}
}
ContinueWithoutLabelInCase:
index: 64
problemMessage: "A continue statement in a switch statement must have a label as a target."
correctionMessage: "Try adding a label associated with one of the case clauses to the continue statement."
analyzerCode: ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE
script:
- "main() { switch (x) {case 1: continue;} }"
DuplicateLabelInSwitchStatement:
index: 72
problemMessage: "The label '#name' was already used in this switch statement."
correctionMessage: "Try choosing a different name for this label."
analyzerCode: ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT
comment: |-
Parameters:
0: the label that was duplicated
statement:
- "switch (0) {l1: case 0: break; l1: case 1: break;}"
LabelNotFound:
problemMessage: "Can't find label '#name'."
correctionMessage: "Try defining the label, or correcting the name to match an existing label."
analyzerCode: LABEL_UNDEFINED
statement:
- "switch (0) {case 0: continue L;}"
InitializedVariableInForEach:
index: 82
problemMessage: "The loop variable in a for-each loop can't be initialized."
correctionMessage: "Try removing the initializer, or using a different kind of loop."
analyzerCode: ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH
statement:
- "for (int a = 0 in <int>[10]) {}"
InvalidAwaitFor:
index: 9
problemMessage: "The keyword 'await' isn't allowed for a normal 'for' statement."
correctionMessage: "Try removing the keyword, or use a for-each statement."
analyzerCode: ParserErrorCode.INVALID_AWAIT_IN_FOR
script:
- "f() async {await for (int i = 0; i < 5; i++) {}}"
InvalidSyncModifier:
problemMessage: "Invalid modifier 'sync'."
correctionMessage: "Try replacing 'sync' with 'sync*'."
analyzerCode: MISSING_STAR_AFTER_SYNC
script: "main() sync {}"
InvalidVoid:
problemMessage: "Type 'void' can't be used here."
correctionMessage: "Try removing 'void' keyword or replace it with 'var', 'final', or a type."
analyzerCode: EXPECTED_TYPE_NAME
script:
- "void x; main() {}"
- "foo(void x) {} main() { foo(null); }"
VoidWithTypeArguments:
problemMessage: "Type 'void' can't have type arguments."
correctionMessage: "Try removing the type arguments."
index: 100
analyzerCode: ParserErrorCode.VOID_WITH_TYPE_ARGUMENTS
script:
- "void<int> f() {}"
# TODO(danrubel): Review where this error is generated and consider generating
# FieldInitializedOutsideDeclaringClass instead of this in some situations.
InvalidInitializer:
index: 90
problemMessage: "Not a valid initializer."
correctionMessage: "To initialize a field, use the syntax 'name = value'."
analyzerCode: ParserErrorCode.INVALID_INITIALIZER
FieldInitializedOutsideDeclaringClass:
index: 88
problemMessage: "A field can only be initialized in its declaring class"
correctionMessage: "Try passing a value into the superclass constructor, or moving the initialization into the constructor body."
analyzerCode: ParserErrorCode.FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS
script:
- "class A { int a; } class C extends A { C() : super.a = 42; }"
FinalFieldNotInitialized:
problemMessage: "Final field '#name' is not initialized."
correctionMessage: "Try to initialize the field in the declaration or in every constructor."
analyzerCode: FINAL_NOT_INITIALIZED
script: >
class C {
final int x;
}
FinalFieldNotInitializedByConstructor:
problemMessage: "Final field '#name' is not initialized by this constructor."
correctionMessage: "Try to initialize the field using an initializing formal or a field initializer."
analyzerCode: FINAL_NOT_INITIALIZED_CONSTRUCTOR_1
script: >
class C {
final int x;
C(this.x) {}
C.missing() {}
}
MissingExponent:
problemMessage: "Numbers in exponential notation should always contain an exponent (an integer number with an optional sign)."
correctionMessage: "Make sure there is an exponent, and remove any whitespace before it."
analyzerCode: MISSING_DIGIT
script: >
main() {
var i = 1e;
}
PositionalParameterWithEquals:
problemMessage: "Positional optional parameters can't use ':' to specify a default value."
correctionMessage: "Try replacing ':' with '='."
analyzerCode: WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER
script: >
main() {
foo([a: 1]) => print(a);
foo(2);
}
RequiredParameterWithDefault:
problemMessage: "Non-optional parameters can't have a default value."
correctionMessage: "Try removing the default value or making the parameter optional."
analyzerCode: NAMED_PARAMETER_OUTSIDE_GROUP
script:
- >
main() {
foo(a: 1) => print(a);
foo(2);
}
- >
main() {
foo(a = 1) => print(a);
foo(2);
}
StackOverflow:
index: 19
problemMessage: "The file has too many nested expressions or statements."
correctionMessage: "Try simplifying the code."
analyzerCode: ParserErrorCode.STACK_OVERFLOW
InvalidCodePoint:
problemMessage: "The escape sequence starting with '\\u' isn't a valid code point."
analyzerCode: INVALID_CODE_POINT
expression:
- "'\\u{110000}'"
InvalidHexEscape:
index: 40
problemMessage: "An escape sequence starting with '\\x' must be followed by 2 hexadecimal digits."
analyzerCode: ParserErrorCode.INVALID_HEX_ESCAPE
expression:
- "'\\x0'"
- "'\\x0y'"
InvalidUnicodeEscapeUStarted:
index: 38
problemMessage: "An escape sequence starting with '\\u' must be followed by 4 hexadecimal digits or from 1 to 6 digits between '{' and '}'."
analyzerCode: ParserErrorCode.INVALID_UNICODE_ESCAPE_U_STARTED
expression:
- "'\\u'"
InvalidUnicodeEscapeUNoBracket:
index: 124
problemMessage: "An escape sequence starting with '\\u' must be followed by 4 hexadecimal digits."
analyzerCode: ParserErrorCode.INVALID_UNICODE_ESCAPE_U_NO_BRACKET
expression:
- "'\\u0F'"
InvalidUnicodeEscapeUBracket:
index: 125
problemMessage: "An escape sequence starting with '\\u{' must be followed by 1 to 6 hexadecimal digits followed by a '}'."
analyzerCode: ParserErrorCode.INVALID_UNICODE_ESCAPE_U_BRACKET
expression:
- "'\\u{'"
- "'\\u{03'"
- "'\\u{0Z}'"
- "'\\u{0000003}'"
InvalidEscapeStarted:
index: 126
problemMessage: "The string '\\' can't stand alone."
correctionMessage: "Try adding another backslash (\\) to escape the '\\'."
analyzerCode: ParserErrorCode.INVALID_UNICODE_ESCAPE_STARTED
exampleAllowMoreCodes: true
expression:
- |
print('Hello, World!\
');
UnexpectedDollarInString:
problemMessage: "A '$' has special meaning inside a string, and must be followed by an identifier or an expression in curly braces ({})."
correctionMessage: "Try adding a backslash (\\) to escape the '$'."
analyzerCode: UNEXPECTED_DOLLAR_IN_STRING
expression:
- "'$'"
- '"$"'
- "'''$'''"
- '"""$"""'
UnexpectedSeparatorInNumber:
problemMessage: "Digit separators ('_') in a number literal can only be placed between two digits."
correctionMessage: "Try removing the '_'."
analyzerCode: UNEXPECTED_SEPARATOR_IN_NUMBER
experiments: digit-separators
expression:
- '123_'
- '1.23_'
- '1_.23'
- '0x_123'
- '0x123_'
- '1_e23'
- '1e_23'
- '1.2_e3'
- '1.2e_3'
UnexpectedToken:
problemMessage: "Unexpected token '#lexeme'."
analyzerCode: UNEXPECTED_TOKEN
script:
- "import 'b.dart' d as b;"
UnexpectedTokens:
problemMessage: "Unexpected tokens."
analyzerCode: ParserErrorCode.UNEXPECTED_TOKENS
index: 123
script: "enum E w Foo { v; }"
LiteralWithClassAndNew:
problemMessage: "A #string literal can't be prefixed by 'new #lexeme'."
correctionMessage: "Try removing 'new' and '#lexeme'"
analyzerCode: ParserErrorCode.LITERAL_WITH_CLASS_AND_NEW
index: 115
script:
- "var x = new Map{};"
- "var x = new Set{};"
- "var x = new List[];"
- "var x = new Map{1: 2};"
- "var x = new Set{1};"
- "var x = new List[1];"
LiteralWithClass:
problemMessage: "A #string literal can't be prefixed by '#lexeme'."
correctionMessage: "Try removing '#lexeme'"
analyzerCode: ParserErrorCode.LITERAL_WITH_CLASS
index: 116
script:
- "var x = Map{};"
- "var x = Set{};"
- "var x = List<String>[];"
- "var x = Map{1: 2};"
- "var x = Set{1};"
- "var x = List<int>[1];"
- "var x = const Map{};"
- "var x = const Set{};"
- "var x = const List[];"
- "var x = const Map{1: 2};"
- "var x = const Set{1};"
- "var x = const List[1];"
LiteralWithNew:
problemMessage: "A literal can't be prefixed by 'new'."
correctionMessage: "Try removing 'new'"
analyzerCode: ParserErrorCode.LITERAL_WITH_NEW
index: 117
script:
- "var x = new <String, String>{};"
- "var x = new <String>{};"
- "var x = new {};"
- "var x = new [];"
- "var x = new <String, String>{'a': 'b'};"
- "var x = new <String>{'a'};"
- "var x = new {'a': 'b'};"
- "var x = new {'a'};"
- "var x = new ['a'];"
UnmatchedToken:
problemMessage: "Can't find '#string' to match '#lexeme'."
analyzerCode: EXPECTED_TOKEN
script:
- "main("
- "main(){"
- "main(){[}"
UnsupportedOperator:
problemMessage: "The '#lexeme' operator is not supported."
analyzerCode: UNSUPPORTED_OPERATOR
script:
- "class C { void operator ===(x) {} }"
- "class C { void operator !==(x) {} }"
UnsupportedPrefixPlus:
problemMessage: "'+' is not a prefix operator."
correctionMessage: "Try removing '+'."
analyzerCode: MISSING_IDENTIFIER
expression: "+2" # No longer a valid way to write '2'
UnterminatedComment:
problemMessage: "Comment starting with '/*' must end with '*/'."
analyzerCode: UNTERMINATED_MULTI_LINE_COMMENT
script:
main() {
}
/*
UnterminatedString:
problemMessage: "String starting with #string must end with #string2."
analyzerCode: UNTERMINATED_STRING_LITERAL
script:
- >
main() {
return '
;
}
- >
main() {
return \"
;
}
- >
main() {
return r'
;
}
- >
main() {
return r\"
;
}
- >
main() => '''
- >
main() => \"\"\"
- >
main() => r'''
- >
main() => r\"\"\"
UnterminatedToken:
# This is a fall-back message that shouldn't happen.
problemMessage: "Incomplete token."
# Note: avoid using this template, it should only be used for debugging and
# prototyping, see [diagnostics.md](
# lib/src/fasta/diagnostics.md#avoid-composing-messages-programmatically).
Unspecified:
problemMessage: "#string"
WeakWithStrongDillLibrary:
problemMessage: "Loaded library is compiled with sound null safety and cannot be used in compilation for unsound null safety."
StrongWithWeakDillLibrary:
problemMessage: "Loaded library is compiled with unsound null safety and cannot be used in compilation for sound null safety."
InvalidNnbdDillLibrary:
problemMessage: "Trying to use library with invalid null safety."
AbstractNotSync:
problemMessage: "Abstract methods can't use 'async', 'async*', or 'sync*'."
analyzerCode: NON_SYNC_ABSTRACT_METHOD
AwaitAsIdentifier:
problemMessage: "'await' can't be used as an identifier in 'async', 'async*', or 'sync*' methods."
analyzerCode: ASYNC_KEYWORD_USED_AS_IDENTIFIER
AwaitNotAsync:
problemMessage: "'await' can only be used in 'async' or 'async*' methods."
analyzerCode: AWAIT_IN_WRONG_CONTEXT
BuiltInIdentifierAsType:
problemMessage: "The built-in identifier '#lexeme' can't be used as a type."
analyzerCode: BUILT_IN_IDENTIFIER_AS_TYPE
BuiltInIdentifierInDeclaration:
problemMessage: "Can't use '#lexeme' as a name here."
analyzerCode: BUILT_IN_IDENTIFIER_IN_DECLARATION
AwaitForNotAsync:
problemMessage: "The asynchronous for-in can only be used in functions marked with 'async' or 'async*'."
correctionMessage: "Try marking the function body with either 'async' or 'async*', or removing the 'await' before the for loop."
analyzerCode: ASYNC_FOR_IN_WRONG_CONTEXT
script: >
main(o) sync* {
await for (var e in o) {}
}
ConstructorNotSync:
problemMessage: "Constructor bodies can't use 'async', 'async*', or 'sync*'."
analyzerCode: NON_SYNC_CONSTRUCTOR
FactoryNotSync:
problemMessage: "Factory bodies can't use 'async', 'async*', or 'sync*'."
analyzerCode: NON_SYNC_FACTORY
GeneratorReturnsValue:
problemMessage: "'sync*' and 'async*' can't return a value."
analyzerCode: RETURN_IN_GENERATOR
InvalidInlineFunctionType:
problemMessage: "Inline function types cannot be used for parameters in a generic function type."
correctionMessage: "Try changing the inline function type (as in 'int f()') to a prefixed function type using the `Function` keyword (as in 'int Function() f')."
analyzerCode: INVALID_INLINE_FUNCTION_TYPE
declaration: "typedef F = Function(int f(String x));"
SetterNotSync:
problemMessage: "Setters can't use 'async', 'async*', or 'sync*'."
analyzerCode: INVALID_MODIFIER_ON_SETTER
YieldAsIdentifier:
problemMessage: "'yield' can't be used as an identifier in 'async', 'async*', or 'sync*' methods."
analyzerCode: ASYNC_KEYWORD_USED_AS_IDENTIFIER
YieldNotGenerator:
problemMessage: "'yield' can only be used in 'sync*' or 'async*' methods."
analyzerCode: YIELD_IN_NON_GENERATOR
OnlyTry:
index: 20
problemMessage: "A try block must be followed by an 'on', 'catch', or 'finally' clause."
correctionMessage: "Try adding either a catch or finally clause, or remove the try statement."
analyzerCode: ParserErrorCode.MISSING_CATCH_OR_FINALLY
statement: "try {}"
TypeAfterVar:
index: 89
problemMessage: "Variables can't be declared using both 'var' and a type name."
correctionMessage: "Try removing 'var.'"
analyzerCode: ParserErrorCode.VAR_AND_TYPE
AssertExtraneousArgument:
problemMessage: "`assert` can't have more than two arguments."
PositionalAfterNamedArgument:
problemMessage: "Place positional arguments before named arguments."
correctionMessage: "Try moving the positional argument before the named arguments, or add a name to the argument."
analyzerCode: POSITIONAL_AFTER_NAMED_ARGUMENT
ExpectedNamedArgument:
problemMessage: "Expected named argument."
analyzerCode: EXTRA_POSITIONAL_ARGUMENTS
AssertAsExpression:
problemMessage: "`assert` can't be used as an expression."
FunctionTypeDefaultValue:
problemMessage: "Can't have a default value in a function type."
analyzerCode: DEFAULT_VALUE_IN_FUNCTION_TYPE
PrivateNamedParameter:
problemMessage: "A named parameter can't start with an underscore ('_')."
analyzerCode: PRIVATE_OPTIONAL_PARAMETER
NoFormals:
problemMessage: "A function should have formal parameters."
correctionMessage: "Try adding '()' after '#lexeme', or add 'get' before '#lexeme' to declare a getter."
analyzerCode: MISSING_FUNCTION_PARAMETERS
GetterWithFormals:
problemMessage: "A getter can't have formal parameters."
correctionMessage: "Try removing '(...)'."
analyzerCode: GETTER_WITH_PARAMETERS
SetterWithWrongNumberOfFormals:
problemMessage: "A setter should have exactly one formal parameter."
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER
CatchSyntax:
index: 84
problemMessage: "'catch' must be followed by '(identifier)' or '(identifier, identifier)'."
correctionMessage: "No types are needed, the first is given by 'on', the second is always 'StackTrace'."
analyzerCode: ParserErrorCode.CATCH_SYNTAX
statement:
- "try {} catch {}"
- "try {} catch () {}"
- "try {} catch (e,) {}"
CatchSyntaxExtraParameters:
index: 83
problemMessage: "'catch' must be followed by '(identifier)' or '(identifier, identifier)'."
correctionMessage: "No types are needed, the first is given by 'on', the second is always 'StackTrace'."
analyzerCode: ParserErrorCode.CATCH_SYNTAX_EXTRA_PARAMETERS
statement:
- "try {} catch (e, s, x) {}"
SuperNullAware:
index: 18
problemMessage: "The operator '?.' cannot be used with 'super' because 'super' cannot be null."
correctionMessage: "Try replacing '?.' with '.'"
analyzerCode: ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER
NullAwareCascadeOutOfOrder:
index: 96
problemMessage: "The '?..' cascade operator must be first in the cascade sequence."
correctionMessage: "Try moving the '?..' operator to be the first cascade operator in the sequence."
analyzerCode: ParserErrorCode.NULL_AWARE_CASCADE_OUT_OF_ORDER
ConstFieldWithoutInitializer:
problemMessage: "The const variable '#name' must be initialized."
correctionMessage: "Try adding an initializer ('= expression') to the declaration."
analyzerCode: CONST_NOT_INITIALIZED
FinalFieldWithoutInitializer:
problemMessage: "The final variable '#name' must be initialized."
correctionMessage: "Try adding an initializer ('= expression') to the declaration."
analyzerCode: FINAL_NOT_INITIALIZED
MetadataTypeArguments:
index: 91
problemMessage: "An annotation can't use type arguments."
analyzerCode: ParserErrorCode.ANNOTATION_WITH_TYPE_ARGUMENTS
MetadataTypeArgumentsUninstantiated:
index: 114
problemMessage: "An annotation with type arguments must be followed by an argument list."
analyzerCode: ParserErrorCode.ANNOTATION_WITH_TYPE_ARGUMENTS_UNINSTANTIATED
script:
- "@deprecated<int> class C {}"
MetadataSpaceBeforeParenthesis:
index: 134
problemMessage: "Annotations can't have spaces or comments before the parenthesis."
correctionMessage: Remove any spaces or comments before the parenthesis.
analyzerCode: ParserErrorCode.ANNOTATION_SPACE_BEFORE_PARENTHESIS
script:
- >-
class Foo<T> {
const Foo();
}
@Foo<int> () var bar;
- >-
class Foo {
const Foo();
}
@Foo () class Bar {}
ConstructorNotFound:
problemMessage: "Couldn't find constructor '#name'."
analyzerCode: CONSTRUCTOR_NOT_FOUND
ConstructorWithReturnType:
index: 55
problemMessage: "Constructors can't have a return type."
correctionMessage: "Try removing the return type."
analyzerCode: ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE
script:
- "class C { int C() {} }"
- "class C { void C.m() {} }"
ConstructorWithTypeParameters:
index: 99
problemMessage: "Constructors can't have type parameters."
analyzerCode: ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR
correctionMessage: "Try removing the type parameters."
script:
- >-
class C { C<T>() {} }
- >-
class C { C.foo<T>() {} }
- >-
class C {
factory C<T>() => new C.internal();
C.internal();
}
- >-
class C {
factory C.foo<T>() => new C.internal();
C.internal();
}
ConstructorWithTypeArguments:
problemMessage: "A constructor invocation can't have type arguments after the constructor name."
correctionMessage: "Try removing the type arguments or placing them after the class name."
analyzerCode: ParserErrorCode.CONSTRUCTOR_WITH_TYPE_ARGUMENTS
index: 118
script:
- "class C<X> { C.foo(); } bar() { new C.foo<int>(); }"
- "class C<X> { C.foo(); } bar() { C.foo<int>(); }"
ConstructorWithWrongName:
problemMessage: "The name of a constructor must match the name of the enclosing class."
analyzerCode: ParserErrorCode.INVALID_CONSTRUCTOR_NAME
index: 102
script:
- >-
class A { B.foo() {} }
- >-
class A {
factory B() => new A.internal();
A.internal();
}
- >-
class A {
factory B.foo() => new A.internal();
A.internal();
}
ConstructorWithWrongNameContext:
problemMessage: "The name of the enclosing class is '#name'."
severity: CONTEXT
ConstructorCyclic:
problemMessage: "Redirecting constructors can't be cyclic."
correctionMessage: "Try to have all constructors eventually redirect to a non-redirecting constructor."
analyzerCode: RECURSIVE_CONSTRUCTOR_REDIRECT
script:
- "class C { C.foo() : this.bar(); C.bar() : this.foo(); }"
FieldInitializerOutsideConstructor:
index: 79
problemMessage: "Field formal parameters can only be used in a constructor."
correctionMessage: "Try removing 'this.'."
analyzerCode: ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
hasPublishedDocs: true
script:
- "class C { void m(this.x); }"
SuperParameterInitializerOutsideConstructor:
problemMessage: "Super-initializer formal parameters can only be used in generative constructors."
correctionMessage: "Try removing 'super.'."
RedirectionTargetNotFound:
problemMessage: "Redirection constructor target not found: '#name'"
analyzerCode: REDIRECT_TO_MISSING_CONSTRUCTOR
CyclicTypedef:
problemMessage: "The typedef '#name' has a reference to itself."
analyzerCode: TYPE_ALIAS_CANNOT_REFERENCE_ITSELF
TypeNotFound:
problemMessage: "Type '#name' not found."
analyzerCode: UNDEFINED_CLASS
NameNotFound:
problemMessage: "Undefined name '#name'."
analyzerCode: UNDEFINED_NAME
MemberNotFound:
problemMessage: "Member not found: '#name'."
analyzerCode: UNDEFINED_GETTER
GetterNotFound:
problemMessage: "Getter not found: '#name'."
analyzerCode: UNDEFINED_GETTER
SetterNotFound:
problemMessage: "Setter not found: '#name'."
analyzerCode: UNDEFINED_SETTER
MethodNotFound:
problemMessage: "Method not found: '#name'."
analyzerCode: UNDEFINED_METHOD
CandidateFound:
problemMessage: "Found this candidate, but the arguments don't match."
severity: CONTEXT
CandidateFoundIsDefaultConstructor:
problemMessage: "The class '#name' has a constructor that takes no arguments."
severity: CONTEXT
MissingArgumentList:
problemMessage: "Constructor invocations must have an argument list."
TooFewArguments:
problemMessage: "Too few positional arguments: #count required, #count2 given."
analyzerCode: NOT_ENOUGH_REQUIRED_ARGUMENTS
TooManyArguments:
problemMessage: "Too many positional arguments: #count allowed, but #count2 found."
correctionMessage: "Try removing the extra positional arguments."
analyzerCode: EXTRA_POSITIONAL_ARGUMENTS
NoSuchNamedParameter:
problemMessage: "No named parameter with the name '#name'."
analyzerCode: UNDEFINED_NAMED_PARAMETER
AbstractClassInstantiation:
problemMessage: "The class '#name' is abstract and can't be instantiated."
analyzerCode: NEW_WITH_ABSTRACT_CLASS
EnumInstantiation:
problemMessage: "Enums can't be instantiated."
analyzerCode: INSTANTIATE_ENUM
AbstractRedirectedClassInstantiation:
problemMessage: "Factory redirects to class '#name', which is abstract and can't be instantiated."
analyzerCode: FACTORY_REDIRECTS_TO_ABSTRACT_CLASS
MissingImplementationNotAbstract:
problemMessage: |
The non-abstract class '#name' is missing implementations for these members:
#names
correctionMessage: |
Try to either
- provide an implementation,
- inherit an implementation from a superclass or mixin,
- mark the class as abstract, or
- provide a 'noSuchMethod' implementation.
analyzerCode: CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
script:
- "class C {foo();}"
MissingImplementationCause:
problemMessage: "'#name' is defined here."
severity: CONTEXT
InterfaceCheck:
problemMessage: "The implementation of '#name' in the non-abstract class '#name2' does not conform to its interface."
NamedMixinOverride:
problemMessage: "The mixin application class '#name' introduces an erroneous override of '#name2'."
ImplicitMixinOverride:
problemMessage: "Applying the mixin '#name' to '#name2' introduces an erroneous override of '#name3'."
ListLiteralTooManyTypeArguments:
problemMessage: "List literal requires exactly one type argument."
analyzerCode: EXPECTED_ONE_LIST_TYPE_ARGUMENTS
SetLiteralTooManyTypeArguments:
problemMessage: "A set literal requires exactly one type argument."
MapLiteralTypeArgumentMismatch:
problemMessage: "A map literal requires exactly two type arguments."
analyzerCode: EXPECTED_TWO_MAP_TYPE_ARGUMENTS
SetOrMapLiteralTooManyTypeArguments:
problemMessage: "A set or map literal requires exactly one or two type arguments, respectively."
LoadLibraryTakesNoArguments:
problemMessage: "'loadLibrary' takes no arguments."
analyzerCode: LOAD_LIBRARY_TAKES_NO_ARGUMENTS
TypeArgumentMismatch:
problemMessage: "Expected #count type arguments."
analyzerCode: WRONG_NUMBER_OF_TYPE_ARGUMENTS
NotAType:
problemMessage: "'#name' isn't a type."
analyzerCode: NOT_A_TYPE
NotATypeContext:
problemMessage: "This isn't a type."
severity: CONTEXT
NotAPrefixInTypeAnnotation:
problemMessage: "'#name.#name2' can't be used as a type because '#name' doesn't refer to an import prefix."
analyzerCode: NOT_A_TYPE
declaration:
- |
class C<T> {
T.String method() {}
}
- |
class C<T> {
T.String field;
}
UnresolvedPrefixInTypeAnnotation:
problemMessage: "'#name.#name2' can't be used as a type because '#name' isn't defined."
analyzerCode: NOT_A_TYPE
statement: "T.String x;"
FastaUsageShort:
problemMessage: |
Frequently used options:
-o <file> Generate the output into <file>.
-h Display this message (add -v for information about all options).
FastaUsageLong:
# TODO(ahe): Consider if the reference to platform.dill needs to change below?
problemMessage: |
Supported options:
-o <file>, --output=<file>
Generate the output into <file>.
-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=<file>
Use package resolution configuration <file>, which should contain a mapping
of package names to paths.
--platform=<file>
Read the SDK platform from <file>, 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=<sdk>
Compile the SDK from scratch instead of reading it from a .dill file
(see --platform).
--sdk=<sdk>
Location of the SDK sources for use when compiling additional platform
libraries.
--single-root-scheme=String
--single-root-base=<dir>
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=<number>
--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=<flag>
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.
FastaCLIArgumentRequired:
problemMessage: "Expected value after '#name'."
NamedFunctionExpression:
problemMessage: "A function expression can't have a name."
analyzerCode: NAMED_FUNCTION_EXPRESSION
NativeClauseShouldBeAnnotation:
index: 23
problemMessage: "Native clause in this form is deprecated."
correctionMessage: "Try removing this native clause and adding @native() or @native('native-name') before the declaration."
analyzerCode: ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION
ReturnTypeFunctionExpression:
problemMessage: "A function expression can't have a return type."
InternalProblemUnhandled:
problemMessage: "Unhandled #string in #string2."
severity: INTERNAL_PROBLEM
InternalProblemUnimplemented:
problemMessage: "Unimplemented #string."
severity: INTERNAL_PROBLEM
InternalProblemUnexpected:
problemMessage: "Expected '#string', but got '#string2'."
severity: INTERNAL_PROBLEM
InternalProblemUnsupported:
problemMessage: "Unsupported operation: '#name'."
severity: INTERNAL_PROBLEM
InternalProblemNotFound:
problemMessage: "Couldn't find '#name'."
severity: INTERNAL_PROBLEM
InternalProblemNotFoundIn:
problemMessage: "Couldn't find '#name' in '#name2'."
severity: INTERNAL_PROBLEM
InternalProblemPrivateConstructorAccess:
problemMessage: "Can't access private constructor '#name'."
severity: INTERNAL_PROBLEM
InternalProblemConstructorNotFound:
problemMessage: "No constructor named '#name' in '#uri'."
severity: INTERNAL_PROBLEM
InternalProblemExtendingUnmodifiableScope:
problemMessage: "Can't extend an unmodifiable scope."
severity: INTERNAL_PROBLEM
InternalProblemPreviousTokenNotFound:
problemMessage: "Couldn't find previous token."
severity: INTERNAL_PROBLEM
InternalProblemStackNotEmpty:
problemMessage: "#name.stack isn't empty:\n #string"
severity: INTERNAL_PROBLEM
InternalProblemAlreadyInitialized:
problemMessage: "Attempt to set initializer on field without initializer."
severity: INTERNAL_PROBLEM
InternalProblemBodyOnAbstractMethod:
problemMessage: "Attempting to set body on abstract method."
severity: INTERNAL_PROBLEM
InternalProblemMissingContext:
problemMessage: "Compiler cannot run without a compiler context."
correctionMessage: "Are calls to the compiler wrapped in CompilerContext.runInContext?"
severity: INTERNAL_PROBLEM
InternalProblemProvidedBothCompileSdkAndSdkSummary:
problemMessage: "The compileSdk and sdkSummary options are mutually exclusive"
severity: INTERNAL_PROBLEM
InternalProblemUriMissingScheme:
problemMessage: "The URI '#uri' has no scheme."
severity: INTERNAL_PROBLEM
InternalProblemContextSeverity:
problemMessage: "Non-context message has context severity: #string"
severity: INTERNAL_PROBLEM
InternalProblemVerificationError:
problemMessage: |
Verification of the generated program failed:
#string
severity: INTERNAL_PROBLEM
VerificationErrorOriginContext:
problemMessage: "The node most likely is taken from here by a transformer."
severity: CONTEXT
InternalProblemDebugAbort:
problemMessage: "Compilation aborted due to fatal '#name' at:\n#string"
severity: INTERNAL_PROBLEM
InternalProblemLabelUsageInVariablesDeclaration:
problemMessage: "Unexpected usage of label inside declaration of variables."
severity: INTERNAL_PROBLEM
InternalProblemUnfinishedTypeVariable:
problemMessage: "Unfinished type variable '#name' found in non-source library '#uri'."
severity: INTERNAL_PROBLEM
InternalProblemUnsupportedNullability:
problemMessage: "Unsupported nullability value '#string' on type '#type'."
severity: INTERNAL_PROBLEM
InternalProblemOmittedTypeNameInConstructorReference:
problemMessage: "Unsupported omission of the type name in a constructor reference outside of an enum element declaration."
severity: INTERNAL_PROBLEM
IncrementalCompilerIllegalParameter:
problemMessage: "Illegal parameter name '#string' found during expression compilation."
IncrementalCompilerIllegalTypeParameter:
problemMessage: "Illegal type parameter name '#string' found during expression compilation."
DebugTrace:
problemMessage: "Fatal '#name' at:\n#string"
severity: IGNORED
MissingPrefixInDeferredImport:
index: 30
problemMessage: "Deferred imports should have a prefix."
correctionMessage: "Try adding a prefix to the import by adding an 'as' clause."
analyzerCode: ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT
DeferredAfterPrefix:
index: 68
problemMessage: "The deferred keyword should come immediately before the prefix ('as' clause)."
correctionMessage: "Try moving the deferred keyword before the prefix."
analyzerCode: ParserErrorCode.DEFERRED_AFTER_PREFIX
DuplicateDeferred:
index: 71
problemMessage: "An import directive can only have one 'deferred' keyword."
correctionMessage: "Try removing all but one 'deferred' keyword."
analyzerCode: ParserErrorCode.DUPLICATE_DEFERRED
DeferredTypeAnnotation:
problemMessage: "The type '#type' is deferred loaded via prefix '#name' and can't be used as a type annotation."
correctionMessage: "Try removing 'deferred' from the import of '#name' or use a supertype of '#type' that isn't deferred."
analyzerCode: TYPE_ANNOTATION_DEFERRED_CLASS
DuplicatePrefix:
index: 73
problemMessage: "An import directive can only have one prefix ('as' clause)."
correctionMessage: "Try removing all but one prefix."
analyzerCode: ParserErrorCode.DUPLICATE_PREFIX
PrefixAfterCombinator:
index: 6
problemMessage: "The prefix ('as' clause) should come before any show/hide combinators."
correctionMessage: "Try moving the prefix before the combinators."
analyzerCode: ParserErrorCode.PREFIX_AFTER_COMBINATOR
DuplicatedExport:
problemMessage: "'#name' is exported from both '#uri' and '#uri2'."
analyzerCode: AMBIGUOUS_EXPORT
script:
lib1.dart: "class A {}"
lib2.dart: "class A {}"
main.dart: "export 'lib1.dart'; export 'lib2.dart';"
DuplicatedExportInType:
problemMessage: "'#name' is exported from both '#uri' and '#uri2'."
DuplicatedImportInType:
problemMessage: "'#name' is imported from both '#uri' and '#uri2'."
analyzerCode: AMBIGUOUS_IMPORT
script:
lib1.dart: "class A {}"
lib2.dart: "class A {}"
main.dart: "import 'lib1.dart'; import 'lib2.dart'; A a;"
CyclicClassHierarchy:
problemMessage: "'#name' is a supertype of itself."
analyzerCode: RECURSIVE_INTERFACE_INHERITANCE
script:
- |
class A extends B {}
class B extends A {}
- |
class A implements B {}
class B implements A {}
- "class C = Object with C;"
- "class C extends C {}"
- "class C implements C {}"
ExtendingEnum:
problemMessage: "'#name' is an enum and can't be extended or implemented."
analyzerCode: EXTENDS_ENUM
ExtendingRestricted:
problemMessage: "'#name' is restricted and can't be extended or implemented."
analyzerCode: EXTENDS_DISALLOWED_CLASS
NoUnnamedConstructorInObject:
problemMessage: "'Object' has no unnamed constructor."
IllegalAsyncGeneratorReturnType:
problemMessage: "Functions marked 'async*' must have a return type assignable to 'Stream'."
analyzerCode: ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE
script:
- >-
int g() async* {
yield 0;
}
IllegalAsyncGeneratorVoidReturnType:
problemMessage: "Functions marked 'async*' can't have return type 'void'."
script:
- >-
void g() async* {
}
IllegalAsyncReturnType:
problemMessage: "Functions marked 'async' must have a return type assignable to 'Future'."
analyzerCode: ILLEGAL_ASYNC_RETURN_TYPE
script:
- >-
int f() async {
return 0;
}
IllegalSyncGeneratorReturnType:
problemMessage: "Functions marked 'sync*' must have a return type assignable to 'Iterable'."
analyzerCode: ILLEGAL_SYNC_GENERATOR_RETURN_TYPE
script:
- >-
int g() sync* {
yield 0;
}
IllegalSyncGeneratorVoidReturnType:
problemMessage: "Functions marked 'sync*' can't have return type 'void'."
script:
- >-
void g() sync* {
}
IllegalMixinDueToConstructors:
# a class with a constructor is used as a mixin
problemMessage: "Can't use '#name' as a mixin because it has constructors."
analyzerCode: MIXIN_DECLARES_CONSTRUCTOR # CompileTimeErrorCode
MixinDeclaresConstructor:
# a mixin declaration contains a constructor declaration
index: 95
problemMessage: "Mixins can't declare constructors."
analyzerCode: ParserErrorCode.MIXIN_DECLARES_CONSTRUCTOR
IllegalMixinDueToConstructorsCause:
problemMessage: "This constructor prevents using '#name' as a mixin."
severity: CONTEXT
ExtensionDeclaresAbstractMember:
index: 94
problemMessage: "Extensions can't declare abstract members."
correctionMessage: "Try providing an implementation for the member."
script: |
extension E on int {
void method();
}
analyzerCode: ParserErrorCode.EXTENSION_DECLARES_ABSTRACT_MEMBER
comment: No parameters.
documentation: |-
#### Description
The analyzer produces this diagnostic when an abstract declaration is
declared in an extension. Extensions can declare only concrete members.
#### Example
The following code produces this diagnostic because the method `a` doesn't
have a body:
```dart
extension E on String {
int [!a!]();
}
```
#### Common fixes
Either provide an implementation for the member or remove it.
hasPublishedDocs: true
ExtensionTypeDeclaresAbstractMember:
problemMessage: "Extension types can't declare abstract members."
correctionMessage: "Try providing an implementation for the member."
analyzerCode: EXTENSION_TYPE_WITH_ABSTRACT_MEMBER
script: |
extension type ET(int id) {
void method();
}
ExtensionDeclaresConstructor:
index: 92
problemMessage: "Extensions can't declare constructors."
correctionMessage: "Try removing the constructor declaration."
script: |
extension E on int {
E();
}
analyzerCode: ParserErrorCode.EXTENSION_DECLARES_CONSTRUCTOR
comment: No parameters.
documentation: |-
#### Description
The analyzer produces this diagnostic when a constructor declaration is
found in an extension. It isn't valid to define a constructor because
extensions aren't classes, and it isn't possible to create an instance of
an extension.
#### Example
The following code produces this diagnostic because there is a constructor
declaration in `E`:
```dart
extension E on String {
[!E!]() : super();
}
```
#### Common fixes
Remove the constructor or replace it with a static method.
hasPublishedDocs: true
ExtensionDeclaresInstanceField:
index: 93
problemMessage: "Extensions can't declare instance fields"
correctionMessage: "Try removing the field declaration or making it a static field"
analyzerCode: ParserErrorCode.EXTENSION_DECLARES_INSTANCE_FIELD
script: |
extension E on int {
int? field;
}
comment: No parameters.
documentation: |-
#### Description
The analyzer produces this diagnostic when an instance field declaration is
found in an extension. It isn't valid to define an instance field because
extensions can only add behavior, not state.
#### Example
The following code produces this diagnostic because `s` is an instance
field:
```dart
%language=2.9
extension E on String {
String [!s!];
}
```
#### Common fixes
Remove the field, make it a static field, or convert it to be a getter,
setter, or method.
hasPublishedDocs: true
ExtensionAugmentationHasOnClause:
index: 179
problemMessage: "Extension augmentations can't have 'on' clauses."
correctionMessage: "Try removing the 'on' clause."
analyzerCode: ParserErrorCode.EXTENSION_AUGMENTATION_HAS_ON_CLAUSE
script: |
augment extension E on int {}
comment: No parameters.
ExtensionTypeDeclaresInstanceField:
problemMessage: "Extension types can't declare instance fields"
correctionMessage: "Try removing the field declaration or making it a static field"
analyzerCode: EXTENSION_TYPE_DECLARES_INSTANCE_FIELD
script: |
extension type ET(int id) {
int? field;
}
ConflictsWithConstructor:
problemMessage: "Conflicts with constructor '#name'."
analyzerCode: CONFLICTS_WITH_CONSTRUCTOR
ConflictsWithFactory:
problemMessage: "Conflicts with factory '#name'."
ConflictsWithMember:
problemMessage: "Conflicts with member '#name'."
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithImplicitSetter:
problemMessage: "Conflicts with the implicit setter of the field '#name'."
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithSetter:
problemMessage: "Conflicts with setter '#name'."
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithTypeVariable:
problemMessage: "Conflicts with type variable '#name'."
analyzerCode: CONFLICTING_TYPE_VARIABLE_AND_MEMBER
ConflictsWithTypeVariableCause:
problemMessage: "This is the type variable."
severity: CONTEXT
ExtensionMemberConflictsWithObjectMember:
problemMessage: "This extension member conflicts with Object member '#name'."
script:
extension Extension on String {
int get noSuchMethod => 42;
}
DeclaredMemberConflictsWithInheritedMember:
problemMessage: "Can't declare a member that conflicts with an inherited one."
analyzerCode: DECLARED_MEMBER_CONFLICTS_WITH_INHERITED
script:
- >-
class A {
var foo;
}
class B extends A {
foo() {}
}
- >-
abstract class A {
get foo;
}
class B implements A {
foo() {}
}
- >-
class A {
foo() {}
}
class B extends A {
var foo;
}
- >-
abstract class A {
foo();
}
class B implements A {
var foo;
}
DeclaredMemberConflictsWithInheritedMemberCause:
problemMessage: "This is the inherited member."
severity: CONTEXT
DeclaredMemberConflictsWithInheritedMembersCause:
problemMessage: "This is one of the inherited members."
severity: CONTEXT
DeclaredMemberConflictsWithOverriddenMembersCause:
problemMessage: "This is one of the overridden members."
severity: CONTEXT
InheritedMembersConflict:
problemMessage: "Can't inherit members that conflict with each other."
analyzerCode: CONFLICTS_WITH_INHERITED_MEMBER
script:
- >-
class A {
foo() {}
}
abstract class B {
get foo;
}
abstract class C extends A implements B {}
- >-
class A {
var foo;
}
abstract class B {
foo();
}
abstract class C extends A implements B {}
- >-
class A {
get foo => 0;
}
abstract class B {
foo();
}
abstract class C extends A implements B {}
InheritedMembersConflictCause1:
problemMessage: "This is one inherited member."
severity: CONTEXT
InheritedMembersConflictCause2:
problemMessage: "This is the other inherited member."
severity: CONTEXT
IllegalMixin:
problemMessage: "The type '#name' can't be mixed in."
analyzerCode: ILLEGAL_MIXIN
OverrideTypeVariablesMismatch:
problemMessage: "Declared type variables of '#name' doesn't match those on overridden method '#name2'."
analyzerCode: INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS
OverrideTypeVariablesBoundMismatch:
problemMessage: "Declared bound '#type' of type variable '#name' of '#name2' doesn't match the bound '#type2' on overridden method '#name3'."
OverriddenMethodCause:
problemMessage: "This is the overridden method ('#name')."
severity: CONTEXT
OverrideMismatchNamedParameter:
problemMessage: "The method '#name' doesn't have the named parameter '#name2' of overridden method '#name3'."
analyzerCode: INVALID_OVERRIDE_NAMED
OverrideFewerNamedArguments:
problemMessage: "The method '#name' has fewer named arguments than those of overridden method '#name2'."
analyzerCode: INVALID_OVERRIDE_NAMED
OverrideFewerPositionalArguments:
problemMessage: "The method '#name' has fewer positional arguments than those of overridden method '#name2'."
analyzerCode: INVALID_OVERRIDE_POSITIONAL
OverrideMoreRequiredArguments:
problemMessage: "The method '#name' has more required arguments than those of overridden method '#name2'."
analyzerCode: INVALID_OVERRIDE_REQUIRED
OverrideTypeMismatchParameter:
problemMessage: "The parameter '#name' of the method '#name2' has type '#type', which does not match the corresponding type, '#type2', in the overridden method, '#name3'."
correctionMessage: "Change to a supertype of '#type2', or, for a covariant parameter, a subtype."
analyzerCode: INVALID_METHOD_OVERRIDE
OverrideTypeMismatchReturnType:
problemMessage: "The return type of the method '#name' is '#type', which does not match the return type, '#type2', of the overridden method, '#name2'."
correctionMessage: "Change to a subtype of '#type2'."
analyzerCode: INVALID_METHOD_OVERRIDE
OverrideTypeMismatchSetter:
problemMessage: "The field '#name' has type '#type', which does not match the corresponding type, '#type2', in the overridden setter, '#name2'."
analyzerCode: INVALID_METHOD_OVERRIDE
OverrideMismatchRequiredNamedParameter:
problemMessage: "The required named parameter '#name' in method '#name2' is not required in overridden method '#name3'."
script: |
abstract class A {
method({int? a});
}
abstract class B implements A {
method({required int? a});
}
InvalidGetterSetterType:
problemMessage: "The type '#type' of the getter '#name' is not a subtype of the type '#type2' of the setter '#name2'."
script: |
abstract class A {
num get property;
void set property(int i);
}
InvalidGetterSetterTypeGetterInherited:
problemMessage: "The type '#type' of the inherited getter '#name' is not a subtype of the type '#type2' of the setter '#name2'."
script: |
abstract class A {
num get property;
}
abstract class B implements A {
void set property(int i);
}
InvalidGetterSetterTypeFieldInherited:
problemMessage: "The type '#type' of the inherited field '#name' is not a subtype of the type '#type2' of the setter '#name2'."
script: |
abstract class A {
final num property;
A(this.property);
}
abstract class B implements A {
void set property(int i);
}
InvalidGetterSetterTypeSetterInheritedGetter:
problemMessage: "The type '#type' of the getter '#name' is not a subtype of the type '#type2' of the inherited setter '#name2'."
script: |
abstract class A {
void set property(int i);
}
abstract class B implements A {
num get property;
}
InvalidGetterSetterTypeSetterInheritedField:
problemMessage: "The type '#type' of the field '#name' is not a subtype of the type '#type2' of the inherited setter '#name2'."
script: |
abstract class A {
void set property(int i);
}
abstract class B implements A {
final num property;
B(this.property);
}
InvalidGetterSetterTypeBothInheritedField:
problemMessage: "The type '#type' of the inherited field '#name' is not a subtype of the type '#type2' of the inherited setter '#name2'."
script: |
abstract class A {
final num property;
A(this.property);
}
abstract class B {
void set property(int i);
}
abstract class C implements A, B {}
InvalidGetterSetterTypeBothInheritedGetter:
problemMessage: "The type '#type' of the inherited getter '#name' is not a subtype of the type '#type2' of the inherited setter '#name2'."
script: |
abstract class A {
num get property;
}
abstract class B {
void set property(int i);
}
abstract class C implements A, B {}
InvalidGetterSetterTypeFieldContext:
problemMessage: "This is the declaration of the field '#name'."
severity: CONTEXT
InvalidGetterSetterTypeGetterContext:
problemMessage: "This is the declaration of the getter '#name'."
severity: CONTEXT
InvalidGetterSetterTypeSetterContext:
problemMessage: "This is the declaration of the setter '#name'."
severity: CONTEXT
PartOfSelf:
problemMessage: "A file can't be a part of itself."
analyzerCode: PART_OF_NON_PART
script:
main.dart: "part 'main.dart';"
TypeVariableDuplicatedName:
problemMessage: "A type variable can't have the same name as another."
analyzerCode: DUPLICATE_DEFINITION
TypeVariableDuplicatedNameCause:
problemMessage: "The other type variable named '#name'."
severity: CONTEXT
TypeVariableSameNameAsEnclosing:
problemMessage: "A type variable can't have the same name as its enclosing declaration."
analyzerCode: CONFLICTING_TYPE_VARIABLE_AND_CLASS
AnnotationOnTypeArgument:
problemMessage: "Type arguments can't have annotations because they aren't declarations."
analyzerCode: ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT
index: 111
script:
- "class A<E> {} class C { m() => new A<@Object() C>(); }"
AnnotationOnFunctionTypeTypeVariable:
problemMessage: "A type variable on a function type can't have annotations."
script: |
// @dart=2.13
main() { Function<@Object() T>() x; }
ExpectedEnumBody:
problemMessage: "Expected a enum body, but got '#lexeme'."
correctionMessage: "An enum definition must have a body with at least one constant name."
analyzerCode: MISSING_ENUM_BODY
script:
- "enum E"
EnumDeclarationEmpty:
problemMessage: "An enum declaration can't be empty."
analyzerCode: EMPTY_ENUM_BODY
script:
- "enum E {}"
ExternalClass:
index: 3
problemMessage: "Classes can't be declared to be 'external'."
correctionMessage: "Try removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_CLASS
script:
- "external class C {}"
ExternalEnum:
index: 5
problemMessage: "Enums can't be declared to be 'external'."
correctionMessage: "Try removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_ENUM
script:
- "external enum E {ONE}"
ExternalMethodWithBody:
# TODO(danrubel): remove reference to `native` once support has been removed
index: 49
problemMessage: "An external or native method can't have a body."
analyzerCode: ParserErrorCode.EXTERNAL_METHOD_WITH_BODY
script:
- "class C {external foo() {}}"
- "class C {foo() native {}}"
- "class C {foo() native 'bar' {}}"
ExternalConstructorWithInitializer:
index: 106
problemMessage: "An external constructor can't have any initializers."
analyzerCode: ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_INITIALIZER
script:
- "class C { int? x; external C() : x = 1; }"
- "class C { int? x; external C.foo() : x = 1; }"
ExternalTypedef:
index: 76
problemMessage: "Typedefs can't be declared to be 'external'."
correctionMessage: "Try removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_TYPEDEF
script:
- "external typedef F();"
OperatorWithOptionalFormals:
problemMessage: "An operator can't have optional parameters."
OperatorWithTypeParameters:
index: 120
problemMessage: "Types parameters aren't allowed when defining an operator."
correctionMessage: "Try removing the type parameters."
analyzerCode: ParserErrorCode.TYPE_PARAMETER_ON_OPERATOR
comment: |-
7.1.1 Operators: Type parameters are not syntactically supported on an
operator.
script:
- "class C { operator []<T>(T t) => null; }"
PlatformPrivateLibraryAccess:
problemMessage: "Can't access platform private library."
analyzerCode: IMPORT_INTERNAL_LIBRARY
TypedefNotFunction:
problemMessage: "Can't create typedef from non-function type."
analyzerCode: INVALID_GENERIC_FUNCTION_TYPE
TypedefNotType:
problemMessage: "Can't create typedef from non-type."
analyzerCode: INVALID_TYPE_IN_TYPEDEF
TypedefTypeVariableNotConstructor:
problemMessage: "Can't use a typedef denoting a type variable as a constructor, nor for a static member access."
TypedefTypeVariableNotConstructorCause:
problemMessage: "This is the type variable ultimately denoted."
severity: CONTEXT
TypedefNullableType:
problemMessage: "Can't create typedef from nullable type."
script: |
// @dart=2.12
typedef F = void Function()?;
TypedefUnaliasedTypeCause:
problemMessage: "This is the type denoted by the type alias."
severity: CONTEXT
TypedefCause:
problemMessage: "The issue arises via this type alias."
severity: CONTEXT
LibraryDirectiveNotFirst:
index: 37
problemMessage: "The library directive must appear before all other directives."
correctionMessage: "Try moving the library directive before any other directives."
analyzerCode: ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST
script:
- "class Foo{} library l;"
- "import 'x.dart'; library l;"
- "part 'a.dart'; library l;"
ImportAfterPart:
index: 10
problemMessage: "Import directives must precede part directives."
correctionMessage: "Try moving the import directives before the part directives."
analyzerCode: ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE
script:
- "part 'foo.dart'; import 'bar.dart';"
ExportAfterPart:
index: 75
problemMessage: "Export directives must precede part directives."
correctionMessage: "Try moving the export directives before the part directives."
analyzerCode: ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE
script:
- "part 'foo.dart'; export 'bar.dart';"
DirectiveAfterDeclaration:
index: 69
problemMessage: "Directives must appear before any declarations."
correctionMessage: "Try moving the directive before any declarations."
analyzerCode: ParserErrorCode.DIRECTIVE_AFTER_DECLARATION
script:
- "class foo { } import 'bar.dart';"
- "class foo { } export 'bar.dart';"
NonPartOfDirectiveInPart:
problemMessage: "The part-of directive must be the only directive in a part."
correctionMessage: "Try removing the other directives, or moving them to the library for which this is a part."
analyzerCode: NON_PART_OF_DIRECTIVE_IN_PART
script:
- "part of l; part 'f.dart';"
PartOfTwice:
index: 25
problemMessage: "Only one part-of directive may be declared in a file."
correctionMessage: "Try removing all but one of the part-of directives."
analyzerCode: ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES
script:
- main.dart: |
part "part.dart";
main() {}
other.dart: ""
part.dart: |
part of "other.dart";
part of "main.dart";
- main.dart: |
part of "lib.dart";
part of "lib.dart";
main() {}
lib.dart: |
part "main.dart";
- main.dart: |
part "part.dart";
part.dart: |
part of "main.dart";
part of "main.dart";
PartTwice:
problemMessage: "Can't use '#uri' as a part more than once."
analyzerCode: DUPLICATE_PART
script:
part.dart: "part of 'main.dart';"
main.dart: "part 'part.dart'; part 'part.dart';"
PartOfTwoLibraries:
problemMessage: "A file can't be part of more than one library."
correctionMessage: "Try moving the shared declarations into the libraries, or into a new library."
analyzerCode: PART_OF_DIFFERENT_LIBRARY
script:
main.dart: "library lib; import 'lib.dart'; part 'part.dart';"
lib.dart: "library lib; part 'part.dart';"
part.dart: "part of lib;"
PartOfTwoLibrariesContext:
problemMessage: "Used as a part in this library."
severity: CONTEXT
FactoryTopLevelDeclaration:
index: 78
problemMessage: "Top-level declarations can't be declared to be 'factory'."
correctionMessage: "Try removing the keyword 'factory'."
analyzerCode: ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION
script:
- "factory class C {}"
RedirectionInNonFactory:
index: 21
problemMessage: "Only factory constructor can specify '=' redirection."
correctionMessage: "Try making this a factory constructor, or remove the redirection."
analyzerCode: ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR
script:
- "class C { C() = D; }"
TopLevelOperator:
index: 14
problemMessage: "Operators must be declared within a class."
correctionMessage: "Try removing the operator, moving it to a class, or converting it to be a function."
analyzerCode: ParserErrorCode.TOP_LEVEL_OPERATOR
script:
- "operator +(bool x, bool y) => x | y;"
- "bool operator +(bool x, bool y) => x | y;"
- "void operator +(bool x, bool y) => x | y;"
MissingFunctionParameters:
problemMessage: "A function declaration needs an explicit list of parameters."
correctionMessage: "Try adding a parameter list to the function declaration."
analyzerCode: MISSING_FUNCTION_PARAMETERS
script:
- "void f {}"
MissingMethodParameters:
problemMessage: "A method declaration needs an explicit list of parameters."
correctionMessage: "Try adding a parameter list to the method declaration."
analyzerCode: MISSING_METHOD_PARAMETERS
script:
- "class C { void m {} }"
MissingTypedefParameters:
problemMessage: "A typedef needs an explicit list of parameters."
correctionMessage: "Try adding a parameter list to the typedef."
analyzerCode: MISSING_TYPEDEF_PARAMETERS
script:
- "typedef void F;"
MissingPartOf:
problemMessage: "Can't use '#uri' as a part, because it has no 'part of' declaration."
analyzerCode: PART_OF_NON_PART
script:
part.dart: ""
main.dart: "part 'part.dart';"
PartOfInLibrary:
problemMessage: "Can't import '#uri', because it has a 'part of' declaration."
correctionMessage: "Try removing the 'part of' declaration, or using '#uri' as a part."
analyzerCode: IMPORT_OF_NON_LIBRARY
script:
main.dart: |
import "part.dart";
import "lib.dart";
main() {}
part.dart: |
part of "lib.dart";
lib.dart: |
part "part.dart";
PartInPart:
problemMessage: "A file that's a part of a library can't have parts itself."
correctionMessage: "Try moving the 'part' declaration to the containing library."
analyzerCode: NON_PART_OF_DIRECTIVE_IN_PART
script:
main.dart: |
part "part.dart";
main() {}
part.dart: |
part of "main.dart";
part "part_part.dart";
part_part.dart: |
part of "part.dart";
PartInPartLibraryContext:
problemMessage: "This is the containing library."
severity: CONTEXT
PartOrphan:
problemMessage: "This part doesn't have a containing library."
correctionMessage: "Try removing the 'part of' declaration."
script: "part of none; main() {}"
PartExport:
problemMessage: "Can't export this file because it contains a 'part of' declaration."
analyzerCode: EXPORT_OF_NON_LIBRARY
script:
main.dart: |
export "part.dart";
import "lib.dart";
main() {}
part.dart: |
part of "lib.dart";
lib.dart: |
part "part.dart";
PartExportContext:
problemMessage: "This is the file that can't be exported."
severity: CONTEXT
SupertypeIsFunction:
problemMessage: "Can't use a function type as supertype."
DeferredPrefixDuplicated:
problemMessage: "Can't use the name '#name' for a deferred library, as the name is used elsewhere."
analyzerCode: SHARED_DEFERRED_PREFIX
DeferredPrefixDuplicatedCause:
problemMessage: "'#name' is used here."
severity: CONTEXT
TypeArgumentsOnTypeVariable:
index: 13
problemMessage: "Can't use type arguments with type variable '#name'."
correctionMessage: "Try removing the type arguments."
analyzerCode: ParserErrorCode.TYPE_ARGUMENTS_ON_TYPE_VARIABLE
script:
- "dynamic<T>(x) => 0"
# Use this message when a duplicated declaration is introduced. For example:
#
# class C {} // First declaration (related information points here).
# class C {} // Duplicated declaration (error here).
# main() {
# new C(); // Use of duplicated declaration.
# }
#
# We follow the convention from C that a definition is the unique element that
# provides the implementation of a name, and a declaration may not be unique
# (for example, forward declaration). Using this terminology, one could argue
# that a method that is abstract or external is a declaration, not a
# definition. Similarly, imported names are declarations, not
# definitions. Consequently, it is more convenient to use the word
# "declaration" instead of "definition" as the former implies less.
DuplicatedDeclaration:
problemMessage: "'#name' is already declared in this scope."
analyzerCode: DUPLICATE_DEFINITION
script: |
class C {} // First declaration (related information points here).
class C {} // Duplicated declaration (error here).
main() {
// The following line is commented out as it would lead to an extraneous
// diagnostic.
// new C(); // Use of duplicated declaration.
}
DuplicatedDeclarationCause:
problemMessage: "Previous declaration of '#name'."
severity: CONTEXT
DuplicatedDeclarationSyntheticCause:
problemMessage: "Previous declaration of '#name' is implied by this definition."
severity: CONTEXT
# Use this message when a duplicated declaration is used.
DuplicatedDeclarationUse:
problemMessage: "Can't use '#name' because it is declared more than once."
exampleAllowMoreCodes: true
script:
- main.dart: |
// This test can't pass as tests must produce only one error message.
class C {} // First declaration (related information points here).
class C {} // Duplicated declaration (error here).
main() {
new C(); // Use of duplicated declaration.
}
- main.dart: |
import 'lib1.dart';
import 'lib2.dart';
main() {
new C(); // Use of duplicated declaration.
}
lib1.dart: |
class C {}
lib2.dart: |
class C {}
DuplicatedNamedArgument:
problemMessage: "Duplicated named argument '#name'."
analyzerCode: DUPLICATE_NAMED_ARGUMENT
DuplicatedParameterName:
problemMessage: "Duplicated parameter name '#name'."
analyzerCode: DUPLICATE_DEFINITION
DuplicatedParameterNameCause:
problemMessage: "Other parameter named '#name'."
severity: CONTEXT
MemberWithSameNameAsClass:
problemMessage: "A class member can't have the same name as the enclosing class."
correctionMessage: "Try renaming the member."
analyzerCode: ParserErrorCode.MEMBER_WITH_CLASS_NAME
index: 105
script:
- "class C { get C {} }"
- "class C { get C => 42; }"
- "class C { set C(x) {} }"
- "class C { set C(x) => 42; }"
- "class C { int? C; }"
- "class C { int? A, B, C, D, E; }"
EnumConstantSameNameAsEnclosing:
problemMessage: "Name of enum constant '#name' can't be the same as the enum's own name."
analyzerCode: ENUM_CONSTANT_WITH_ENUM_NAME
MissingOperatorKeyword:
index: 31
problemMessage: "Operator declarations must be preceded by the keyword 'operator'."
correctionMessage: "Try adding the keyword 'operator'."
analyzerCode: ParserErrorCode.MISSING_KEYWORD_OPERATOR
script:
- "class C { +(x) {} }"
InvalidOperator:
index: 39
problemMessage: "The string '#lexeme' isn't a user-definable operator."
analyzerCode: ParserErrorCode.INVALID_OPERATOR
comment: |-
Parameters:
0: the operator that is invalid
script:
- "class C { void operator %=(x) {} }"
NotBinaryOperator:
problemMessage: "'#lexeme' isn't a binary operator."
script: >
class C { operator~() { return null; } }
main() {
C c = new C();
print(c ~ 2);
}
OperatorParameterMismatch0:
problemMessage: "Operator '#name' shouldn't have any parameters."
OperatorParameterMismatch1:
problemMessage: "Operator '#name' should have exactly one parameter."
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
OperatorParameterMismatch2:
problemMessage: "Operator '#name' should have exactly two parameters."
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
OperatorMinusParameterMismatch:
problemMessage: "Operator '#name' should have zero or one parameter."
correctionMessage: >-
With zero parameters, it has the syntactic form '-a', formally known as 'unary-'.
With one parameter, it has the syntactic form 'a - b', formally known as '-'.
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS
SupertypeIsIllegal:
problemMessage: "The type '#name' can't be used as supertype."
analyzerCode: EXTENDS_NON_CLASS
script: |
class C extends dynamic {}
SupertypeIsIllegalAliased:
problemMessage: "The type '#name' which is an alias of '#type' can't be used as supertype."
analyzerCode: EXTENDS_NON_CLASS
script: |
typedef F = void Function();
class C extends F {}
SupertypeIsNullableAliased:
problemMessage: "The type '#name' which is an alias of '#type' can't be used as supertype because it is nullable."
analyzerCode: EXTENDS_NON_CLASS
script: |
class A {}
typedef B = A?;
class C extends B {}
SupertypeIsTypeVariable:
problemMessage: "The type variable '#name' can't be used as supertype."
analyzerCode: EXTENDS_NON_CLASS
script: |
class C<T> extends T {}
SuperExtensionTypeIsIllegal:
problemMessage: "The type '#name' can't be implemented by an extension type."
script: |
extension type E(dynamic it) implements dynamic {}
SuperExtensionTypeIsIllegalAliased:
problemMessage: "The type '#name' which is an alias of '#type' can't be implemented by an extension type."
script: |
typedef F = void Function();
extension type E(F it) implements F {}
SuperExtensionTypeIsNullableAliased:
problemMessage: "The type '#name' which is an alias of '#type' can't be implemented by an extension type because it is nullable."
script: |
class A {}
typedef B = A?;
extension type E(B it) implements B {}
SuperExtensionTypeIsTypeVariable:
problemMessage: "The type variable '#name' can't be implemented by an extension type."
script: |
extension type E<T>(T it) implements T {}
PartOfLibraryNameMismatch:
problemMessage: "Using '#uri' as part of '#name' but its 'part of' declaration says '#name2'."
analyzerCode: PART_OF_DIFFERENT_LIBRARY
PartOfUseUri:
problemMessage: "Using '#uri' as part of '#uri2' but its 'part of' declaration says '#name'."
correctionMessage: "Try changing the 'part of' declaration to use a relative file name."
analyzerCode: PART_OF_UNNAMED_LIBRARY
PartOfUriMismatch:
problemMessage: "Using '#uri' as part of '#uri2' but its 'part of' declaration says '#uri3'."
analyzerCode: PART_OF_DIFFERENT_LIBRARY
MissingMain:
problemMessage: "No 'main' method found."
correctionMessage: "Try adding a method named 'main' to your program."
MissingInput:
problemMessage: "No input file provided to the compiler."
InputFileNotFound:
problemMessage: "Input file not found: #uri."
SdkRootNotFound:
problemMessage: "SDK root directory not found: #uri."
SdkSummaryNotFound:
problemMessage: "SDK summary not found: #uri."
SdkSpecificationNotFound:
problemMessage: "SDK libraries specification not found: #uri."
correctionMessage: "Normally, the specification is a file named 'libraries.json' in the Dart SDK install location."
InvalidSuperInInitializer:
index: 47
problemMessage: "Can only use 'super' in an initializer for calling the superclass constructor (e.g. 'super()' or 'super.namedConstructor()')"
analyzerCode: ParserErrorCode.INVALID_SUPER_IN_INITIALIZER
InvalidThisInInitializer:
index: 65
problemMessage: "Can only use 'this' in an initializer for field initialization (e.g. 'this.x = something') and constructor redirection (e.g. 'this()' or 'this.namedConstructor())"
analyzerCode: ParserErrorCode.INVALID_THIS_IN_INITIALIZER
ThisAccessInFieldInitializer:
problemMessage: "Can't access 'this' in a field initializer to read '#name'."
analyzerCode: THIS_ACCESS_FROM_FIELD_INITIALIZER
ThisOrSuperAccessInFieldInitializer:
problemMessage: "Can't access '#string' in a field initializer."
analyzerCode: THIS_ACCESS_FROM_INITIALIZER
ThisAsIdentifier:
problemMessage: "Expected identifier, but got 'this'."
analyzerCode: INVALID_REFERENCE_TO_THIS
# TODO(johnniwinther): Confusing message, it should probably mention that `super` is not available.
SuperAsIdentifier:
problemMessage: "Expected identifier, but got 'super'."
analyzerCode: SUPER_AS_EXPRESSION
InvalidAugmentSuper:
problemMessage: "'augment super' is only allowed in member augmentations."
SuperAsExpression:
problemMessage: "Can't use 'super' as an expression."
correctionMessage: "To delegate a constructor to a super constructor, put the super call as an initializer."
analyzerCode: SUPER_AS_EXPRESSION
SwitchExpressionNotAssignable:
problemMessage: "Type '#type' of the switch expression isn't assignable to the type '#type2' of this case expression."
analyzerCode: SWITCH_EXPRESSION_NOT_ASSIGNABLE
configuration: nnbd-weak
SwitchExpressionNotAssignableCause:
problemMessage: "The switch expression is here."
severity: CONTEXT
SwitchExpressionNotSubtype:
problemMessage: "Type '#type' of the case expression is not a subtype of type '#type2' of this switch expression."
configuration: nnbd-weak
script:
- |
// @dart=2.19
void f() {
switch (42) {
case "foo": break;
}
}
SwitchHasCaseAfterDefault:
index: 16
problemMessage: "The default case should be the last case in a switch statement."
correctionMessage: "Try moving the default case after the other case clauses."
analyzerCode: ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE
script:
- "class C { foo(int a) {switch (a) {default: return 0; case 1: return 1;}} }"
SwitchHasMultipleDefaults:
index: 15
problemMessage: "The 'default' case can only be declared once."
correctionMessage: "Try removing all but one default case."
analyzerCode: ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES
script:
- "class C { foo(int a) {switch (a) {default: return 0; default: return 1;}} }"
SwitchCaseFallThrough:
problemMessage: "Switch case may fall through to the next case."
analyzerCode: CASE_BLOCK_NOT_TERMINATED
FieldAlreadyInitializedAtDeclaration:
problemMessage: "'#name' is a final instance variable that was initialized at the declaration."
analyzerCode: FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION
script:
- "class C { final int x = 2; C(): this.x = 3 {} }"
FieldAlreadyInitializedAtDeclarationCause:
problemMessage: "'#name' was initialized here."
severity: CONTEXT
ConstructorInitializeSameInstanceVariableSeveralTimes:
problemMessage: "'#name' was already initialized by this constructor."
analyzerCode: FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS
script:
- "class C { final int x; C(): this.x = 1, this.x = 2 {} }"
- "class C { int x; C(): this.x = 1, this.x = 2 {} }"
TypeVariableInStaticContext:
problemMessage: "Type variables can't be used in static members."
analyzerCode: TYPE_PARAMETER_REFERENCED_BY_STATIC
declaration:
- |
class C<T> {
static List<T> staticMethod() {}
}
- |
class C<T> {
static T staticMethod() {}
}
- |
class C<T> {
static staticMethod(List<T> argument) {}
}
- |
class C<T> {
static staticMethod(T argument) {}
}
- |
class C<T> {
static staticMethod() {
List<T>? t = null;
return t;
}
}
- |
class C<T> {
static staticMethod() {
T? t = null;
return t;
}
}
TypeVariableInConstantContext:
problemMessage: "Type variables can't be used as constants."
analyzerCode: TYPE_PARAMETER_IN_CONST_EXPRESSION
declaration:
- |
class C<T> {
instanceMethod() {
return const <Object>[T];
}
}
- |
class C<T> {
instanceMethod() {
return const <T>[];
}
}
- |
class C<T> {
instanceMethod() {
return const <List<T>>[];
}
}
SuperclassMethodArgumentMismatch:
problemMessage: "Superclass doesn't have a method named '#name' with matching arguments."
SuperclassHasNoMember:
problemMessage: "Superclass has no member named '#name'."
analyzerCode: UNDEFINED_SUPER_GETTER
SuperclassHasNoGetter:
problemMessage: "Superclass has no getter named '#name'."
analyzerCode: UNDEFINED_SUPER_GETTER
SuperclassHasNoSetter:
problemMessage: "Superclass has no setter named '#name'."
analyzerCode: UNDEFINED_SUPER_SETTER
SuperclassHasNoMethod:
problemMessage: "Superclass has no method named '#name'."
analyzerCode: UNDEFINED_SUPER_METHOD
SuperclassHasNoConstructor:
problemMessage: "Superclass has no constructor named '#name'."
analyzerCode:
- UNDEFINED_CONSTRUCTOR_IN_INITIALIZER
- UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
script:
- |
class Super {
Super._();
}
class Sub extends Super {
Sub() : super();
}
- |
class Super {
Super._();
}
class Sub extends Super {
Sub.foo() : super.foo();
}
SuperclassHasNoDefaultConstructor:
problemMessage: "The superclass, '#name', has no unnamed constructor that takes no arguments."