blob: ed49e2b387aed5f0a50ecca789e0c840b6f807cd [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.
# Each entry in this map corresponds to a diagnostic message. Ideally, each
# entry contains three parts:
#
# 1. A message template (template).
#
# 2. A suggestion for how to correct the problem (tip).
#
# 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 existance of the file will be verified.
#
# 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.
#
# In some cases a mesage is internal to the frontend, and no meaningful
# analyzer code can be provided. In such cases set `frontendInternal: true`.
#
# ## Parameter Substitution in Template and Tip
#
# The fields `template` and `tip` 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`: names (as 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).
#
# `#type`, #type2`: 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:
template: "The control character #unicode can only be used in strings and comments."
analyzerCode: ILLEGAL_CHARACTER
expression: "\x1b 1"
ConstEvalContext:
template: "While analyzing:"
ConstEvalDuplicateKey:
template: "The key '#constant' conflicts with another existing key in the map."
analyzerCode: EQUAL_KEYS_IN_MAP
ConstEvalNonConstantLiteral:
template: "Can't have a non-constant #string literal within a const context."
analyzerCode: NON_CONSTANT_DEFAULT_VALUE
ConstEvalInvalidType:
template: "Expected constant '#constant' to be of type '#type', but was of type '#type2'."
ConstEvalInvalidBinaryOperandType:
template: "Binary operator '#string' on '#constant' requires operand of type '#type', but was of type '#type2'."
ConstEvalZeroDivisor:
template: "Binary operator '#string' on '#string2' requires non-zero divisor, but divisor was '0'."
analyzerCode: CONST_EVAL_THROWS_IDBZE
ConstEvalNegativeShift:
template: "Binary operator '#string' on '#string2' requires non-negative operand, but was '#string3'."
ConstEvalInvalidMethodInvocation:
template: "The method '#string' can't be invoked on '#constant' within a const context."
analyzerCode: UNDEFINED_OPERATOR
ConstEvalInvalidStringInterpolationOperand:
template: "The '#constant' can't be used as part of a string interpolation within a const context, only values of type 'null', 'bool', 'int', 'double', or 'String' can be used."
analyzerCode: CONST_EVAL_TYPE_BOOL_NUM_STRING
ConstEvalInvalidStaticInvocation:
template: "The invocation of '#name' is not allowed within a const context."
analyzerCode: CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
ConstEvalFailedAssertion:
template: "This assertion failed."
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalFailedAssertionWithMessage:
template: "This assertion failed with message: #string"
analyzerCode: CONST_EVAL_THROWS_EXCEPTION
ConstEvalNonConstantVariableGet:
template: "The variable '#string' is not a constant, only constant expressions are allowed."
analyzerCode: NON_CONSTANT_VALUE_IN_INITIALIZER
ConstEvalDeferredLibrary:
template: >
'#name' can't be used in a constant expression because it's marked as
'deferred' which means it isn't available until loaded.
tip: >
Try moving the constant from the deferred library, or removing 'deferred'
from the import.
analyzerCode: NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY
NotConstantExpression:
template: "#string is not a constant expression."
analyzerCode: NOT_CONSTANT_EXPRESSION
NotAConstantExpression:
template: "Not a constant expression."
analyzerCode: NOT_CONSTANT_EXPRESSION
NonAsciiIdentifier:
template: "The non-ASCII character '#character' (#unicode) can't be used in identifiers, only in strings and comments."
tip: "Try using an US-ASCII letter, a digit, '_' (an underscore), or '$' (a dollar sign)."
analyzerCode: ILLEGAL_CHARACTER
expression: "å"
NonAsciiWhitespace:
template: "The non-ASCII space character #unicode can only be used in strings and comments."
analyzerCode: ILLEGAL_CHARACTER
expression: "\u2028 1"
Encoding:
template: "Unable to decode bytes as UTF-8."
bytes: [255]
EmptyNamedParameterList:
template: "Named parameter lists cannot be empty."
tip: "Try adding a named parameter to the list."
analyzerCode: "MISSING_IDENTIFIER"
script: >
foo({}) {}
main() {
foo();
}
EmptyOptionalParameterList:
template: "Optional parameter lists cannot be empty."
tip: "Try adding an optional parameter to the list."
analyzerCode: "MISSING_IDENTIFIER"
script: >
foo([]) {}
main() {
foo();
}
ExpectedBlock:
template: "Expected a block."
tip: "Try adding {}."
analyzerCode: EXPECTED_TOKEN
script: "try finally {}"
ExpectedBlockToSkip:
template: "Expected a function body or '=>'."
# TODO(ahe): In some scenarios, we can suggest removing the 'static' keyword.
tip: "Try adding {}."
analyzerCode: MISSING_FUNCTION_BODY
script: "main();"
ExpectedBody:
template: "Expected a function body or '=>'."
# TODO(ahe): In some scenarios, we can suggest removing the 'static' keyword.
tip: "Try adding {}."
analyzerCode: MISSING_FUNCTION_BODY
script: "main();"
ExpectedStatement:
template: "Expected a statement."
analyzerCode: MISSING_STATEMENT
statement: "void;"
ExpectedButGot:
# Also see ExpectedAfterButGot
template: "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
template: "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 }"
MultipleLibraryDirectives:
template: "Only one library directive may be declared in a file."
tip: "Try removing all but one of the library directives."
analyzerCode: MULTIPLE_LIBRARY_DIRECTIVES
MultipleExtends:
template: "Each class definition can have at most one extends clause."
tip: "Try choosing one superclass and define your class to implement (or mix in) the others."
analyzerCode: MULTIPLE_EXTENDS_CLAUSES
script: "class A extends B extends C {}"
MultipleWith:
template: "Each class definition can have at most one with clause."
tip: "Try combining all of the with clauses into a single clause."
analyzerCode: MULTIPLE_WITH_CLAUSES
script: "class A extends B with C, D with E {}"
WithBeforeExtends:
index: 11
template: "The extends clause must be before the with clause."
tip: "Try moving the extends clause before the with clause."
analyzerCode: ParserErrorCode.WITH_BEFORE_EXTENDS
script: "class B {} class A with B extends C {}"
ImplementsBeforeExtends:
template: "The extends clause must be before the implements clause."
tip: "Try moving the extends clause before the implements clause."
analyzerCode: IMPLEMENTS_BEFORE_EXTENDS
script: "class A implements B extends C {}"
ImplementsBeforeOn:
template: "The on clause must be before the implements clause."
tip: "Try moving the on clause before the implements clause."
analyzerCode: IMPLEMENTS_BEFORE_ON
script: "mixin A implements B on C {}"
ImplementsBeforeWith:
template: "The with clause must be before the implements clause."
tip: "Try moving the with clause before the implements clause."
analyzerCode: IMPLEMENTS_BEFORE_WITH
script: "class A extends B implements C with D {}"
ImplementsRepeated:
template: "'#name' can only be implemented once."
analyzerCode: IMPLEMENTS_REPEATED
tip: "Try removing #count of the occurrences."
script:
- >-
abstract class I {}
abstract class J {}
class K implements I, J, I {}
ImplementsSuperClass:
template: "'#name' can't be used in both 'extends' and 'implements' clauses."
analyzerCode: IMPLEMENTS_SUPER_CLASS
tip: "Try removing one of the occurrences."
script:
- >-
abstract class A {}
class C extends A implements A {}
MultipleImplements:
template: "Each class definition can have at most one implements clause."
tip: "Try combining all of the implements clauses into a single clause."
analyzerCode: MULTIPLE_IMPLEMENTS_CLAUSES
script: "class A implements B implements C, D {}"
MultipleOnClauses:
template: "Each mixin definition can have at most one on clause."
tip: "Try combining all of the on clauses into a single clause."
analyzerCode: MULTIPLE_ON_CLAUSES
script: "mixin A on B on C, D {}"
ImplementsFutureOr:
template: "'FutureOr' can't be used in an 'implements' clause."
script:
- >-
import 'dart:async';
class A implements FutureOr<int> {}
ExpectedClassOrMixinBody:
template: "Expected a class or mixin body, but got '#lexeme'."
analyzerCode: MISSING_CLASS_BODY
ExpectedClassBodyToSkip: ExpectedClassOrMixinBody
ExpectedDeclaration:
template: "Expected a declaration, but got '#lexeme'."
analyzerCode: EXPECTED_EXECUTABLE
ExpectedClassMember:
template: "Expected a class member, but got '#lexeme'."
analyzerCode: EXPECTED_CLASS_MEMBER
ExpectedFunctionBody:
template: "Expected a function body, but got '#lexeme'."
analyzerCode: MISSING_FUNCTION_BODY
ExpectedHexDigit:
template: "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:
template: "Expected an identifier, but got '#lexeme'."
analyzerCode: MISSING_IDENTIFIER
script: "do() {} main() {}"
EqualityCannotBeEqualityOperand:
index: 1
template: "An equality expression can't be an operand of another equality expression."
tip: "Try re-writing the expression."
analyzerCode: ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
script:
- "main() { var b = a < b < c; }"
- "main() { var b = a == b != c; }"
ExpectedOpenParens:
template: "Expected '('."
ExpectedString:
template: "Expected a String, but got '#lexeme'."
analyzerCode: EXPECTED_STRING_LITERAL
ExpectedToken:
template: "Expected to find '#string'."
analyzerCode: EXPECTED_TOKEN
ExpectedType:
template: "Expected a type, but got '#lexeme'."
analyzerCode: EXPECTED_TYPE_NAME
MissingExpressionInThrow:
template: "Missing expression after 'throw'."
tip: "Add an expression after 'throw' or use 'rethrow' to throw a caught exception"
analyzerCode: MISSING_EXPRESSION_IN_THROW
statement:
- "throw;"
MissingConstFinalVarOrType:
template: "Variables must be declared using the keywords 'const', 'final', 'var' or a type name."
tip: "Try adding the name of the type of the variable or the keyword 'var'."
analyzerCode: MISSING_CONST_FINAL_VAR_OR_TYPE
script:
- "class C { static f; }"
FunctionTypedParameterVar:
template: "Function-typed parameters can't specify 'const', 'final' or 'var' in place of a return type."
tip: "Try replacing the keyword with a return type."
analyzerCode: FUNCTION_TYPED_PARAMETER_VAR
script:
- "void f(const x()) {}"
- "void f(final x()) {}"
- "void f(var x()) {}"
AbstractClassMember:
template: "Members of classes can't be declared to be 'abstract'."
tip: "Try removing the 'abstract' keyword. You can add the 'abstract' keyword before the class declaration."
analyzerCode: ABSTRACT_CLASS_MEMBER
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);}"
- "abstract class C {abstract f;}"
- "abstract class C {abstract static f;}"
ClassInClass:
template: "Classes can't be declared inside other classes."
tip: "Try moving the class to the top-level."
analyzerCode: CLASS_IN_CLASS
script:
- "class C { class B {} }"
EnumInClass:
template: "Enums can't be declared inside classes."
tip: "Try moving the enum to the top-level."
analyzerCode: ENUM_IN_CLASS
script:
- "class Foo { enum Bar { Bar1, Bar2, Bar3 } }"
TypedefInClass:
index: 7
template: "Typedefs can't be declared inside classes."
tip: "Try moving the typedef to the top-level."
analyzerCode: ParserErrorCode.TYPEDEF_IN_CLASS
script:
- "abstract class C { typedef int F(int x); }"
CovariantMember:
template: "Getters, setters and methods can't be declared to be 'covariant'."
tip: "Try removing the 'covariant' keyword."
analyzerCode: COVARIANT_MEMBER
script:
- "static covariant get x => 0;"
- "covariant int m() => 0;"
VarReturnType:
index: 12
template: "The return type can't be 'var'."
tip: "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:
template: "Classes can't be declared to be 'const'."
tip: "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: CONST_CLASS
script: "const class C {}"
ConstAndCovariant:
template: "Members can't be declared to be both 'const' and 'covariant'."
tip: "Try removing either the 'const' or 'covariant' keyword."
analyzerCode: CONST_AND_COVARIANT
script:
- "class C { covariant const C f; }"
- "class C { const covariant C f; }"
ConstAndFinal:
template: "Members can't be declared to be both 'const' and 'final'."
tip: "Try removing either the 'const' or 'final' keyword."
analyzerCode: 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;"
ConstAndVar:
template: "Members can't be declared to be both 'const' and 'var'."
tip: "Try removing either the 'const' or 'var' keyword."
analyzerCode: CONST_AND_VAR
script:
- "class C { const var x; }"
- "class C { var const x; }"
ConstFactory:
template: "Only redirecting factory constructors can be declared to be 'const'."
tip: "Try removing the 'const' keyword, or replacing the body with '=' followed by a valid target."
analyzerCode: CONST_FACTORY
script:
- "class C { const factory C() {} }"
ConstFactoryRedirectionToNonConst:
template: "Constant factory constructor can't delegate to a non-constant constructor."
tip: "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:
template: "Cannot invoke a non-'const' factory where a const expression is expected."
tip: "Try using a constructor or factory that is 'const'."
analyzerCode: NOT_CONSTANT_EXPRESSION
NonConstConstructor:
template: "Cannot invoke a non-'const' constructor where a const expression is expected."
tip: "Try using a constructor or factory that is 'const'."
analyzerCode: NOT_CONSTANT_EXPRESSION
ConstAfterFactory:
template: "The modifier 'const' should be before the modifier 'factory'."
tip: "Try re-ordering the modifiers."
analyzerCode: CONST_AFTER_FACTORY
script:
- "class C { factory const C() = prefix.B.foo; }"
ConstConstructorWithBody:
template: "A const constructor can't have a body."
tip: "Try removing either the 'const' keyword or the body."
analyzerCode: CONST_CONSTRUCTOR_WITH_BODY
script:
- "class C { const C() {} }"
ConstMethod:
template: "Getters, setters and methods can't be declared to be 'const'."
tip: "Try removing the 'const' keyword."
analyzerCode: CONST_METHOD
script:
- "class C { const m() {} }"
CovariantAfterFinal:
template: "The modifier 'covariant' should be before the modifier 'final'."
tip: "Try re-ordering the modifiers."
analyzerCode: COVARIANT_AFTER_FINAL
script:
- "final covariant f;"
CovariantAfterVar:
index: 8
template: "The modifier 'covariant' should be before the modifier 'var'."
tip: "Try re-ordering the modifiers."
analyzerCode: ParserErrorCode.COVARIANT_AFTER_VAR
script:
- "var covariant f;"
CovariantAndStatic:
template: "Members can't be declared to be both 'covariant' and 'static'."
tip: "Try removing either the 'covariant' or 'static' keyword."
analyzerCode: COVARIANT_AND_STATIC
script:
- "class C { covariant static A f; }"
- "class C { static covariant A f; }"
DuplicatedModifier:
template: "The modifier '#lexeme' was already specified."
tip: "Try removing all but one occurance of the modifier."
analyzerCode: DUPLICATED_MODIFIER
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; }"
ExternalAfterConst:
template: "The modifier 'external' should be before the modifier 'const'."
tip: "Try re-ordering the modifiers."
analyzerCode: EXTERNAL_AFTER_CONST
script:
- "class C { const external C(); }"
ExternalAfterFactory:
template: "The modifier 'external' should be before the modifier 'factory'."
tip: "Try re-ordering the modifiers."
analyzerCode: EXTERNAL_AFTER_FACTORY
script:
- "class C { factory external C(); }"
ExternalAfterStatic:
template: "The modifier 'external' should be before the modifier 'static'."
tip: "Try re-ordering the modifiers."
analyzerCode: EXTERNAL_AFTER_STATIC
script:
- "class C { static external f(); }"
ExternalConstructorWithBody:
template: "External constructors can't have a body."
tip: "Try removing the body of the constructor, or removing the keyword 'external'."
analyzerCode: EXTERNAL_CONSTRUCTOR_WITH_BODY
script:
- "class C { external C() {} }"
ExternalConstructorWithFieldInitializers:
template: "An external constructor can't initialize fields."
tip: "Try removing the field initializers, or removing the keyword 'external'."
analyzerCode: EXTERNAL_CONSTRUCTOR_WITH_FIELD_INITIALIZERS
ExternalFactoryWithBody:
template: "External factories can't have a body."
tip: "Try removing the body of the factory, or removing the keyword 'external'."
analyzerCode: EXTERNAL_CONSTRUCTOR_WITH_BODY
script:
- "class C { external factory C() {} }"
ExternalField:
template: "Fields can't be declared to be 'external'."
tip: "Try removing the keyword 'external'."
analyzerCode: EXTERNAL_FIELD
script:
- "class C { external var f; }"
InitializerForStaticField:
template: "'#name' isn't an instance field of this class."
analyzerCode: INITIALIZER_FOR_STATIC_FIELD
InitializerOutsideConstructor:
template: "Only constructors can have initializers, and '#name' is not a constructor."
analyzerCode: INITIALIZER_OUTSIDE_CONSTRUCTOR
MoreThanOneSuperOrThisInitializer:
template: "Can't have more than one 'super' or 'this' initializer."
analyzerCode: SUPER_IN_REDIRECTING_CONSTRUCTOR
script:
- "class C { C.bad() : super(), super(); }"
- "class C { C(); C.bad() : super(), this(); }"
- "class C { C(); C.bad() : this(), super(); }"
- "class C { C(); C.bad() : this(), this(); }"
ThisInitializerNotAlone:
template: "Can't have other initializers together with 'this'."
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; }"
SuperInitializerNotLast:
template: "Can't have initializers after 'super'."
analyzerCode: INVALID_SUPER_INVOCATION
script:
- "class C { int x; C.bad() : super(), x = 5; }"
ConstConstructorWithNonConstSuper:
template: "Constant constructor can't call non-constant super constructors."
analyzerCode: CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER
ExtraneousModifier:
template: "Can't have modifier '#lexeme' here."
tip: "Try removing '#lexeme'."
analyzerCode: 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(){}"
- "final class C {}"
- "abstract enum foo {bar}"
- "abstract void foo() {}"
- "static void foo() {}"
- "abstract typedef foo();"
- "static typedef foo();"
FinalAndCovariant:
template: "Members can't be declared to be both 'final' and 'covariant'."
tip: "Try removing either the 'final' or 'covariant' keyword."
analyzerCode: FINAL_AND_COVARIANT
script:
- "class C { covariant final f = 5; }"
- "class C { final covariant f = 5; }"
FinalAndVar:
template: "Members can't be declared to be both 'final' and 'var'."
tip: "Try removing the keyword 'var'."
analyzerCode: FINAL_AND_VAR
script:
- "class C { final var x = 5; }"
- "class C { var final x = 5; }"
StaticAfterConst:
index: 20
template: "The modifier 'static' should be before the modifier 'const'."
tip: "Try re-ordering the modifiers."
analyzerCode: ParserErrorCode.STATIC_AFTER_CONST
script:
- "class C { const static int f; }"
StaticAfterFinal:
index: 19
template: "The modifier 'static' should be before the modifier 'final'."
tip: "Try re-ordering the modifiers."
analyzerCode: ParserErrorCode.STATIC_AFTER_FINAL
script:
- "class C { final static int f = 5; }"
StaticAfterVar:
index: 18
template: "The modifier 'static' should be before the modifier 'var'."
tip: "Try re-ordering the modifiers."
analyzerCode: ParserErrorCode.STATIC_AFTER_VAR
script:
- "class C { var static f; }"
StaticConstructor:
index: 4
template: "Constructors can't be static."
tip: "Try removing the keyword 'static'."
analyzerCode: ParserErrorCode.STATIC_CONSTRUCTOR
script:
- "class C { static C() {} }"
- "class C { static C.m() {} }"
StaticOperator:
index: 17
template: "Operators can't be static."
tip: "Try removing the keyword 'static'."
analyzerCode: ParserErrorCode.STATIC_OPERATOR
script:
- "class C { static operator +(int x) => x + 1; }"
BreakOutsideOfLoop:
template: "A break statement can't be used outside of a loop or switch statement."
tip: "Try removing the break statement."
analyzerCode: BREAK_OUTSIDE_OF_LOOP
script:
- "main() { break; }"
InvalidBreakTarget:
template: "Can't break to '#name'."
BreakTargetOutsideFunction:
template: "Can't break to '#name' in a different function."
analyzerCode: LABEL_IN_OUTER_SCOPE
ContinueOutsideOfLoop:
index: 2
template: "A continue statement can't be used outside of a loop or switch statement."
tip: "Try removing the continue statement."
analyzerCode: ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP
script:
- "main() { continue; }"
InvalidContinueTarget:
template: "Can't continue at '#name'."
ContinueTargetOutsideFunction:
template: "Can't continue at '#name' in a different function."
analyzerCode: LABEL_IN_OUTER_SCOPE
ContinueLabelNotTarget:
template: "Target of continue must be a label."
analyzerCode: LABEL_UNDEFINED
ContinueWithoutLabelInCase:
template: "A continue statement in a switch statement must have a label as a target."
tip: "Try adding a label associated with one of the case clauses to the continue statement."
analyzerCode: CONTINUE_WITHOUT_LABEL_IN_CASE
script:
- "main() { switch (x) {case 1: continue;} }"
DuplicateLabelInSwitchStatement:
template: "The label '#name' was already used in this switch statement."
tip: "Try choosing a different name for this label."
analyzerCode: DUPLICATE_LABEL_IN_SWITCH_STATEMENT
statement:
- "switch (0) {l1: case 0: break; l1: case 1: break;}"
LabelNotFound:
template: "Can't find label '#name'."
tip: "Try defining the label, or correcting the name to match an existing label."
analyzerCode: LABEL_UNDEFINED
statement:
- "switch (0) {case 0: continue L;}"
InitializedVariableInForEach:
template: "The loop variable in a for-each loop can't be initialized."
tip: "Try removing the initializer, or using a different kind of loop."
analyzerCode: INITIALIZED_VARIABLE_IN_FOR_EACH
statement:
- "for (int a = 0 in <int>[10]) {}"
InvalidAwaitFor:
index: 9
template: "The keyword 'await' isn't allowed for a normal 'for' statement."
tip: "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:
template: "Invalid modifier 'sync'."
tip: "Try replacing 'sync' with 'sync*'."
analyzerCode: MISSING_STAR_AFTER_SYNC
script: "main() sync {}"
InvalidVoid:
template: "Type 'void' can't be used here because it isn't a return type."
tip: "Try removing 'void' keyword or replace it with 'var', 'final', or a type."
analyzerCode: INVALID_USE_OF_VOID
script:
- "void x; main() {}"
- "foo(void x) {} main() { foo(null); }"
InvalidInitializer:
template: "Not a valid initializer."
tip: "To initialize a field, use the syntax 'name = value'."
analyzerCode: INVALID_INITIALIZER
FinalFieldNotInitialized:
template: "Final field '#name' is not initialized."
tip: "Try to initialize the field in the declaration or in every constructor."
analyzerCode: FINAL_NOT_INITIALIZED
script: >
class C {
final int x;
}
FinalFieldNotInitializedByConstructor:
template: "Final field '#name' is not initialized by this constructor."
tip: "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:
template: "Numbers in exponential notation should always contain an exponent (an integer number with an optional sign)."
tip: "Make sure there is an exponent, and remove any whitespace before it."
analyzerCode: MISSING_DIGIT
script: >
main() {
var i = 1e;
}
PositionalParameterWithEquals:
template: "Positional optional parameters can't use ':' to specify a default value."
tip: "Try replacing ':' with '='."
analyzerCode: WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER
script: >
main() {
foo([a: 1]) => print(a);
foo(2);
}
RequiredParameterWithDefault:
template: "Non-optional parameters can't have a default value."
tip: "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:
template: "Stack overflow."
analyzerCode: STACK_OVERFLOW
InvalidCodePoint:
template: "The escape sequence starting with '\\u' isn't a valid code point."
analyzerCode: INVALID_CODE_POINT
expression:
- "'\\u{110000}'"
InvalidHexEscape:
template: "An escape sequence starting with '\\x' must be followed by 2 hexidecimal digits."
analyzerCode: INVALID_HEX_ESCAPE
expression:
- "'\\x0'"
- "'\\x0y'"
InvalidUnicodeEscape:
template: "An escape sequence starting with '\\u' must be followed by 4 hexidecimal digits or from 1 to 6 digits between '{' and '}'."
analyzerCode: INVALID_UNICODE_ESCAPE
expression:
- "'\\u'"
- "'\\u0F'"
- "'\\u{'"
- "'\\u{03'"
- "'\\u{0Z}'"
UnexpectedDollarInString:
template: "A '$' has special meaning inside a string, and must be followed by an identifier or an expression in curly braces ({})."
tip: "Try adding a backslash (\\) to escape the '$'."
analyzerCode: UNEXPECTED_DOLLAR_IN_STRING
script:
- >
main() {
return '$';
}
- >
main() {
return "$";
}
- >
main() {
return '''$''';
}
- >
main() {
return """$""";
}
UnexpectedToken:
template: "Unexpected token '#lexeme'."
analyzerCode: UNEXPECTED_TOKEN
script:
- "import 'b.dart' d as b;"
UnmatchedToken:
template: "Can't find '#string' to match '#lexeme'."
analyzerCode: EXPECTED_TOKEN
script:
- "main("
- "main(){"
- "main(){[}"
UnsupportedOperator:
template: "The '#lexeme' operator is not supported."
analyzerCode: UNSUPPORTED_OPERATOR
script:
- "class C { void operator ===(x) {} }"
- "class C { void operator !==(x) {} }"
UnsupportedPrefixPlus:
template: "'+' is not a prefix operator."
tip: "Try removing '+'."
analyzerCode: MISSING_IDENTIFIER
script: "main() => +2; // No longer a valid way to write '2'"
UnterminatedComment:
template: "Comment starting with '/*' must end with '*/'."
analyzerCode: UNTERMINATED_MULTI_LINE_COMMENT
script:
main() {
}
/*
UnterminatedString:
template: "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.
template: "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:
template: "#string"
AbstractNotSync:
template: "Abstract methods can't use 'async', 'async*', or 'sync*'."
analyzerCode: NON_SYNC_ABSTRACT_METHOD
AsyncAsIdentifier:
analyzerCode: ASYNC_KEYWORD_USED_AS_IDENTIFIER
template: "'async' can't be used as an identifier in 'async', 'async*', or 'sync*' methods."
AwaitAsIdentifier:
template: "'await' can't be used as an identifier in 'async', 'async*', or 'sync*' methods."
analyzerCode: ASYNC_KEYWORD_USED_AS_IDENTIFIER
AwaitNotAsync:
template: "'await' can only be used in 'async' or 'async*' methods."
analyzerCode: AWAIT_IN_WRONG_CONTEXT
BuiltInIdentifierAsType:
template: "The built-in identifier '#lexeme' can't be used as a type."
tip: "Try correcting the name to match an existing type."
analyzerCode: BUILT_IN_IDENTIFIER_AS_TYPE
BuiltInIdentifierInDeclaration:
template: "Can't use '#lexeme' as a name here."
analyzerCode: BUILT_IN_IDENTIFIER_IN_DECLARATION
AwaitForNotAsync:
template: "The asynchronous for-in can only be used in functions marked with 'async' or 'async*'."
tip: "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:
template: "Constructor bodies can't use 'async', 'async*', or 'sync*'."
analyzerCode: NON_SYNC_CONSTRUCTOR
FactoryNotSync:
template: "Factory bodies can't use 'async', 'async*', or 'sync*'."
analyzerCode: NON_SYNC_FACTORY
GeneratorReturnsValue:
template: "'sync*' and 'async*' can't return a value."
analyzerCode: RETURN_IN_GENERATOR
InvalidInlineFunctionType:
template: "Inline function types cannot be used for parameters in a generic function type."
tip: "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:
template: "Setters can't use 'async', 'async*', or 'sync*'."
analyzerCode: INVALID_MODIFIER_ON_SETTER
YieldAsIdentifier:
template: "'yield' can't be used as an identifier in 'async', 'async*', or 'sync*' methods."
analyzerCode: ASYNC_KEYWORD_USED_AS_IDENTIFIER
YieldNotGenerator:
template: "'yield' can only be used in 'sync*' or 'async*' methods."
analyzerCode: YIELD_IN_NON_GENERATOR
OnlyTry:
template: "Try block should be followed by 'on', 'catch', or 'finally' block."
tip: "Did you forget to add a 'finally' block?"
analyzerCode: MISSING_CATCH_OR_FINALLY
statement: "try {}"
TypeAfterVar:
template: "Can't have both a type and 'var'."
tip: "Try removing 'var.'"
analyzerCode: VAR_AND_TYPE
AssertExtraneousArgument:
template: "`assert` can't have more than two arguments."
PositionalAfterNamedArgument:
template: "Place positional arguments before named arguments."
tip: "Try moving the positional argument before the named arguments, or add a name to the argument."
analyzerCode: POSITIONAL_AFTER_NAMED_ARGUMENT
ExpectedNamedArgument:
template: "Expected named argument."
analyzerCode: EXTRA_POSITIONAL_ARGUMENTS
AssertAsExpression:
template: "`assert` can't be used as an expression."
FunctionTypeDefaultValue:
template: "Can't have a default value in a function type."
analyzerCode: DEFAULT_VALUE_IN_FUNCTION_TYPE
PrivateNamedParameter:
template: "An optional named parameter can't start with '_'."
analyzerCode: PRIVATE_OPTIONAL_PARAMETER
NoFormals:
template: "A function should have formal parameters."
tip: "Try adding '()' after '#lexeme', or add 'get' before '#lexeme' to declare a getter."
analyzerCode: MISSING_FUNCTION_PARAMETERS
GetterWithFormals:
template: "A getter can't have formal parameters."
tip: "Try removing '(...)'."
analyzerCode: GETTER_WITH_PARAMETERS
SetterWithWrongNumberOfFormals:
template: "A setter should have exactly one formal parameter."
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER
CatchSyntax:
template: "'catch' must be followed by '(identifier)' or '(identifier, identifier)'."
tip: "No types are needed, the first is given by 'on', the second is always 'StackTrace'."
analyzerCode: CATCH_SYNTAX
statement:
- "try {} catch {}"
- "try {} catch () {}"
- "try {} catch (e,) {}"
CatchSyntaxExtraParameters:
template: "'catch' must be followed by '(identifier)' or '(identifier, identifier)'."
tip: "No types are needed, the first is given by 'on', the second is always 'StackTrace'."
analyzerCode: CATCH_SYNTAX
statement:
- "try {} catch (e, s, x) {}"
SuperNullAware:
template: "'super' can't be null."
tip: "Try replacing '?.' with '.'"
analyzerCode: INVALID_OPERATOR_FOR_SUPER
ConstFieldWithoutInitializer:
template: "The const variable '#name' must be initialized."
tip: "Try adding an initializer ('= <expression>') to the declaration."
analyzerCode: CONST_NOT_INITIALIZED
FinalFieldWithoutInitializer:
template: "The final variable '#name' must be initialized."
tip: "Try adding an initializer ('= <expression>') to the declaration."
analyzerCode: FINAL_NOT_INITIALIZED
MetadataTypeArguments:
template: "An annotation (metadata) can't use type arguments."
analyzerCode: ANNOTATION_WITH_TYPE_ARGUMENTS
ConstructorNotFound:
template: "Couldn't find constructor '#name'."
severity: ERROR_LEGACY_WARNING
analyzerCode: CONSTRUCTOR_NOT_FOUND
ConstructorWithReturnType:
template: "Constructors can't have a return type."
tip: "Try removing the return type."
analyzerCode: CONSTRUCTOR_WITH_RETURN_TYPE
script:
- "class C { int C() {} }"
ConstructorWithTypeParameters:
template: "Constructors can't have type parameters."
analyzerCode: TYPE_PARAMETER_ON_CONSTRUCTOR
script:
- "class C { C<T>() {} }"
- "class C { C.foo<T>() {} }"
- "class C { factory C<T>() => null; }"
- "class C { factory C.foo<T>() => null; }"
ConstructorWithTypeArguments:
template: "A constructor invocation can't have type arguments on the constructor name."
tip: "Try to place the type arguments on the class name."
analyzerCode: UNDEFINED_CLASS
script:
- "class C<X> { C.foo(); } bar() { new C.foo<int>(); }"
ConstructorWithWrongName:
template: "The name of a constructor must match the name of the enclosing class."
analyzerCode: INVALID_CONSTRUCTOR_NAME
script:
- "class A { B.foo() {} }"
- "class A { factory B() => null; }"
- "class A { factory B.foo() => null; }"
ConstructorWithWrongNameContext:
template: "The name of the enclosing class is '#name'."
severity: CONTEXT
ConstructorCyclic:
template: "Redirecting constructers can't be cyclic."
tip: "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:
template: "Field formal parameters can only be used in a constructor."
tip: "Try removing 'this.'."
analyzerCode: FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
script:
- "class C { void m(this.x); }"
RedirectionTargetNotFound:
template: "Redirection constructor target not found: '#name'"
severity: ERROR_LEGACY_WARNING
analyzerCode: REDIRECT_TO_MISSING_CONSTRUCTOR
CyclicTypedef:
template: "The typedef '#name' has a reference to itself."
analyzerCode: TYPE_ALIAS_CANNOT_REFERENCE_ITSELF
TypeNotFound:
template: "Type '#name' not found."
severity: ERROR_LEGACY_WARNING
analyzerCode: UNDEFINED_CLASS
NonInstanceTypeVariableUse:
template: "Can only use type variables in instance methods."
severity: ERROR_LEGACY_WARNING
analyzerCode: TYPE_PARAMETER_REFERENCED_BY_STATIC
GetterNotFound:
template: "Getter not found: '#name'."
analyzerCode: UNDEFINED_GETTER
severity: ERROR_LEGACY_WARNING
SetterNotFound:
template: "Setter not found: '#name'."
analyzerCode: UNDEFINED_SETTER
severity: ERROR_LEGACY_WARNING
MethodNotFound:
template: "Method not found: '#name'."
analyzerCode: UNDEFINED_METHOD
severity: ERROR_LEGACY_WARNING
CandidateFound:
template: "Found this candidate, but the arguments don't match."
severity: CONTEXT
CandidateFoundIsDefaultConstructor:
template: "The class '#name' has a constructor that takes no arguments."
severity: CONTEXT
MissingArgumentList:
template: "Constructor invocations must have an argument list."
TooFewArguments:
template: "Too few positional arguments: #count required, #count2 given."
severity: ERROR_LEGACY_WARNING
analyzerCode: NOT_ENOUGH_REQUIRED_ARGUMENTS
TooManyArguments:
template: "Too many positional arguments: #count allowed, but #count2 found."
tip: "Try removing the extra positional arguments."
severity: ERROR_LEGACY_WARNING
analyzerCode: EXTRA_POSITIONAL_ARGUMENTS
NoSuchNamedParameter:
template: "No named parameter with the name '#name'."
severity: ERROR_LEGACY_WARNING
analyzerCode: UNDEFINED_NAMED_PARAMETER
AbstractClassInstantiation:
template: "The class '#name' is abstract and can't be instantiated."
severity: ERROR_LEGACY_WARNING
analyzerCode: NEW_WITH_ABSTRACT_CLASS
EnumInstantiation:
template: "Enums can't be instantiated."
analyzerCode: INSTANTIATE_ENUM
AbstractRedirectedClassInstantiation:
template: "Factory redirects to class '#name', which is abstract and can't be instantiated."
severity: ERROR_LEGACY_WARNING
analyzerCode: FACTORY_REDIRECTS_TO_ABSTRACT_CLASS
MissingImplementationNotAbstract:
template: |
The non-abstract class '#name' is missing implementations for these members:
#string.
tip: |
Try to either
- provide an implementation,
- inherit an implementation from a superclass or mixin,
- mark the class as abstract, or
- provide a 'noSuchMethod' implementation.
severity: ERROR_LEGACY_WARNING
analyzerCode: CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
script:
- "class C {foo();}"
MissingImplementationCause:
template: "'#name' is defined here."
severity: CONTEXT
ListLiteralTooManyTypeArguments:
template: "List literal requires exactly one type argument."
severity: ERROR_LEGACY_WARNING
analyzerCode: EXPECTED_ONE_LIST_TYPE_ARGUMENTS
MapLiteralTypeArgumentMismatch:
template: "Map literal requires exactly two type arguments."
severity: ERROR_LEGACY_WARNING
analyzerCode: EXPECTED_TWO_MAP_TYPE_ARGUMENTS
LoadLibraryTakesNoArguments:
template: "'loadLibrary' takes no arguments."
severity: ERROR_LEGACY_WARNING
analyzerCode: LOAD_LIBRARY_TAKES_NO_ARGUMENTS
LoadLibraryHidesMember:
template: "The library '#uri' defines a top-level member named 'loadLibrary'. This member is hidden by the special member 'loadLibrary' that the language adds to support deferred loading."
tip: "Try to rename or hide the member."
severity: IGNORED
TypeArgumentMismatch:
template: "Expected #count type arguments."
severity: ERROR_LEGACY_WARNING
analyzerCode: WRONG_NUMBER_OF_TYPE_ARGUMENTS
NotAType:
template: "'#name' isn't a type."
severity: ERROR_LEGACY_WARNING
analyzerCode: NOT_A_TYPE
NotAPrefixInTypeAnnotation:
template: "'#name.#name2' can't be used as a type because '#name' doesn't refer to an import prefix."
severity: ERROR_LEGACY_WARNING
analyzerCode: NOT_A_TYPE
declaration:
- |
class C<T> {
T.String method() {}
}
- |
class C<T> {
T.String field;
}
UnresolvedPrefixInTypeAnnotation:
template: "'#name.#name2' can't be used as a type because '#name' isn't defined."
severity: ERROR_LEGACY_WARNING
analyzerCode: NOT_A_TYPE
statement: "T.String x;"
FastaUsageShort:
template: |
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?
template: |
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.
--
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|dart_runner|flutter|flutter_runner|none|vm
Specify the target configuration.
--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.
--bytecode
Generate bytecode. Supported only for SDK platform compilation.
--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.
--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.
FastaCLIArgumentRequired:
template: "Expected value after '#name'."
NamedFunctionExpression:
template: "A function expression can't have a name."
analyzerCode: NAMED_FUNCTION_EXPRESSION
NativeClauseShouldBeAnnotation:
template: "Native clause in this form is deprecated."
tip: "Try removing this native clause and adding @native() or @native('native-name') before the declaration."
analyzerCode: NATIVE_CLAUSE_SHOULD_BE_ANNOTATION
ReturnTypeFunctionExpression:
template: "A function expression can't have a return type."
severity: ERROR_LEGACY_WARNING
InternalProblemUnhandled:
template: "Unhandled #string in #string2."
severity: INTERNAL_PROBLEM
InternalProblemUnimplemented:
template: "Unimplemented #string."
severity: INTERNAL_PROBLEM
InternalProblemUnexpected:
template: "Expected '#string', but got '#string2'."
severity: INTERNAL_PROBLEM
InternalProblemUnsupported:
template: "Unsupported operation: '#name'."
severity: INTERNAL_PROBLEM
InternalProblemSuperclassNotFound:
template: "Superclass not found '#name'."
severity: INTERNAL_PROBLEM
InternalProblemNotFound:
template: "Couldn't find '#name'."
severity: INTERNAL_PROBLEM
InternalProblemNotFoundIn:
template: "Couldn't find '#name' in '#name2'."
severity: INTERNAL_PROBLEM
InternalProblemPrivateConstructorAccess:
template: "Can't access private constructor '#name'."
severity: INTERNAL_PROBLEM
InternalProblemConstructorNotFound:
template: "No constructor named '#name' in '#uri'."
severity: INTERNAL_PROBLEM
InternalProblemExtendingUnmodifiableScope:
template: "Can't extend an unmodifiable scope."
severity: INTERNAL_PROBLEM
InternalProblemPreviousTokenNotFound:
template: "Couldn't find previous token."
severity: INTERNAL_PROBLEM
InternalProblemStackNotEmpty:
template: "#name.stack isn't empty:\n #string"
severity: INTERNAL_PROBLEM
InternalProblemAlreadyInitialized:
template: "Attempt to set initializer on field without initializer."
severity: INTERNAL_PROBLEM
InternalProblemBodyOnAbstractMethod:
template: "Attempting to set body on abstract method."
severity: INTERNAL_PROBLEM
InternalProblemMissingContext:
template: "Compiler cannot run without a compiler context."
tip: "Are calls to the compiler wrapped in CompilerContext.runInContext?"
severity: INTERNAL_PROBLEM
InternalProblemProvidedBothCompileSdkAndSdkSummary:
template: "The compileSdk and sdkSummary options are mutually exclusive"
severity: INTERNAL_PROBLEM
InternalProblemUriMissingScheme:
template: "The URI '#uri' has no scheme."
severity: INTERNAL_PROBLEM
InternalProblemContextSeverity:
template: "Non-context message has context severity: #string"
severity: INTERNAL_PROBLEM
InternalProblemVerificationError:
template: |
Verification of the generated program failed:
#string
severity: INTERNAL_PROBLEM
InternalProblemDebugAbort:
template: "Compilation aborted due to fatal '#name' at:\n#string"
severity: INTERNAL_PROBLEM
LocalDefinitionHidesExport:
template: "Local definition of '#name' hides export from '#uri'."
severity: IGNORED
LocalDefinitionHidesImport:
template: "Local definition of '#name' hides import from '#uri'."
severity: IGNORED
ExportHidesExport:
template: "Export of '#name' (from '#uri') hides export from '#uri2'."
severity: IGNORED
ImportHidesImport:
template: "Import of '#name' (from '#uri') hides import from '#uri2'."
severity: IGNORED
MissingPrefixInDeferredImport:
template: "Deferred imports should have a prefix."
tip: "Try adding a prefix to the import."
analyzerCode: MISSING_PREFIX_IN_DEFERRED_IMPORT
DeferredAfterPrefix:
template: "The deferred keyword should come immediately before the prefix ('as' clause)."
tip: "Try moving the deferred keyword before the prefix."
analyzerCode: DEFERRED_AFTER_PREFIX
DuplicateDeferred:
template: "An import directive can only have one 'deferred' keyword."
tip: "Try removing all but one 'deferred' keyword."
analyzerCode: DUPLICATE_DEFERRED
DeferredTypeAnnotation:
template: "The type '#type' is deferred loaded via prefix '#name' and can't be used as a type annotation."
tip: "Try removing 'deferred' from the import of '#name' or use a supertype of '#type' that isn't deferred."
severity: ERROR_LEGACY_WARNING
analyzerCode: TYPE_ANNOTATION_DEFERRED_CLASS
DuplicatePrefix:
template: "An import directive can only have one prefix ('as' clause)."
tip: "Try removing all but one prefix."
analyzerCode: DUPLICATE_PREFIX
PrefixAfterCombinator:
index: 6
template: "The prefix ('as' clause) should come before any show/hide combinators."
tip: "Try moving the prefix before the combinators."
analyzerCode: ParserErrorCode.PREFIX_AFTER_COMBINATOR
DuplicatedExport:
template: "'#name' is exported from both '#uri' and '#uri2'."
severity: IGNORED
analyzerCode: AMBIGUOUS_EXPORT
DuplicatedExportInType:
template: "'#name' is exported from both '#uri' and '#uri2'."
severity: ERROR_LEGACY_WARNING
DuplicatedImport:
template: "'#name' is imported from both '#uri' and '#uri2'."
severity: IGNORED
DuplicatedImportInType:
template: "'#name' is imported from both '#uri' and '#uri2'."
severity: ERROR_LEGACY_WARNING
analyzerCode: AMBIGUOUS_IMPORT
script:
lib1.dart: "class A {}"
lib2.dart: "class A {}"
main.dart: "import 'lib1.dart'; import 'lib2.dart'; A a;"
CyclicClassHierarchy:
template: "'#name' is a supertype of itself via '#string'."
analyzerCode: RECURSIVE_INTERFACE_INHERITANCE
ExtendingEnum:
template: "'#name' is an enum and can't be extended or implemented."
analyzerCode: EXTENDS_ENUM
ExtendingRestricted:
template: "'#name' is restricted and can't be extended or implemented."
analyzerCode: EXTENDS_DISALLOWED_CLASS
NoUnnamedConstructorInObject:
template: "'Object' has no unnamed constructor."
IllegalAsyncGeneratorReturnType:
template: "Functions marked 'async*' must have a return type assignable to 'Stream'."
analyzerCode: ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE
script:
- >-
int g() async* {
yield 0;
}
IllegalAsyncGeneratorVoidReturnType:
template: "Functions marked 'async*' can't have return type 'void'."
script:
- >-
void g() async* {
}
IllegalAsyncReturnType:
template: "Functions marked 'async' must have a return type assignable to 'Future'."
analyzerCode: ILLEGAL_ASYNC_RETURN_TYPE
script:
- >-
int f() async {
return 0;
}
IllegalSyncGeneratorReturnType:
template: "Functions marked 'sync*' must have a return type assignable to 'Iterable'."
analyzerCode: ILLEGAL_SYNC_GENERATOR_RETURN_TYPE
script:
- >-
int g() sync* {
yield 0;
}
IllegalSyncGeneratorVoidReturnType:
template: "Functions marked 'sync*' can't have return type 'void'."
script:
- >-
void g() sync* {
}
IllegalMixinDueToConstructors:
template: "Can't use '#name' as a mixin because it has constructors."
analyzerCode: MIXIN_DECLARES_CONSTRUCTOR
IllegalMixinDueToConstructorsCause:
template: "This constructor prevents using '#name' as a mixin."
severity: CONTEXT
ConflictsWithConstructor:
template: "Conflicts with constructor '#name'."
analyzerCode: CONFLICTS_WITH_CONSTRUCTOR
ConflictsWithFactory:
template: "Conflicts with factory '#name'."
ConflictsWithMember:
template: "Conflicts with member '#name'."
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithMemberWarning:
template: "Conflicts with member '#name'."
severity: ERROR_LEGACY_WARNING
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithSetter:
template: "Conflicts with setter '#name'."
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithSetterWarning:
template: "Conflicts with setter '#name'."
severity: ERROR_LEGACY_WARNING
analyzerCode: CONFLICTS_WITH_MEMBER
ConflictsWithTypeVariable:
template: "Conflicts with type variable '#name'."
analyzerCode: CONFLICTING_TYPE_VARIABLE_AND_MEMBER
ConflictsWithTypeVariableCause:
template: "This is the type variable."
severity: CONTEXT
DeclaredMemberConflictsWithInheritedMember:
template: "Can't declare a member that conflicts with an inherited one."
severity: ERROR_LEGACY_WARNING
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:
template: "This is the inherited member."
severity: CONTEXT
InheritedMembersConflict:
template: "Can't inherit members that conflict with each other."
severity: ERROR_LEGACY_WARNING
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:
template: "This is one inherited member."
severity: CONTEXT
InheritedMembersConflictCause2:
template: "This is the other inherited member."
severity: CONTEXT
IllegalMixin:
template: "The type '#name' can't be mixed in."
analyzerCode: ILLEGAL_MIXIN
OverrideTypeVariablesMismatch:
template: "Declared type variables of '#name' doesn't match those on overridden method '#name2'."
severity: ERROR_LEGACY_WARNING
analyzerCode: INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS
OverriddenMethodCause:
template: "This is the overriden method ('#name')."
severity: CONTEXT
OverrideMismatchNamedParameter:
template: "The method '#name' doesn't have the named parameter '#name2' of overriden method '#name3'."
severity: ERROR_LEGACY_WARNING
analyzerCode: INVALID_OVERRIDE_NAMED
OverrideFewerNamedArguments:
template: "The method '#name' has fewer named arguments than those of overridden method '#name2'."
severity: ERROR_LEGACY_WARNING
analyzerCode: INVALID_OVERRIDE_NAMED
OverrideFewerPositionalArguments:
template: "The method '#name' has fewer positional arguments than those of overridden method '#name2'."
severity: ERROR_LEGACY_WARNING
analyzerCode: INVALID_OVERRIDE_POSITIONAL
OverrideMoreRequiredArguments:
template: "The method '#name' has more required arguments than those of overridden method '#name2'."
severity: ERROR_LEGACY_WARNING
analyzerCode: INVALID_OVERRIDE_REQUIRED
OverrideTypeMismatchParameter:
template: "The parameter '#name' of the method '#name2' has type #type, which does not match the corresponding type in the overridden method (#type2)."
tip: "Change to a supertype of #type2 (or, for a covariant parameter, a subtype)."
analyzerCode: INVALID_METHOD_OVERRIDE
OverrideTypeMismatchReturnType:
template: "The return type of the method '#name' is #type, which does not match the return type of the overridden method (#type2)."
tip: "Change to a subtype of #type2."
analyzerCode: INVALID_METHOD_OVERRIDE
PartOfSelf:
template: "A file can't be a part of itself."
analyzerCode: PART_OF_NON_PART
script:
main.dart: "part 'main.dart';"
TypeVariableDuplicatedName:
template: "A type variable can't have the same name as another."
analyzerCode: DUPLICATE_DEFINITION
TypeVariableDuplicatedNameCause:
template: "The other type variable named '#name'."
severity: CONTEXT
TypeVariableSameNameAsEnclosing:
template: "A type variable can't have the same name as its enclosing declaration."
analyzerCode: CONFLICTING_TYPE_VARIABLE_AND_CLASS
ExpectedEnumBody:
template: "Expected a enum body, but got '#lexeme'."
tip: "An enum definition must have a body with at least one constant name."
analyzerCode: MISSING_ENUM_BODY
script:
- "enum E"
EnumDeclarationEmpty:
template: "An enum declaration can't be empty."
analyzerCode: EMPTY_ENUM_BODY
script:
- "enum E {}"
ExternalClass:
index: 3
template: "Classes can't be declared to be 'external'."
tip: "Try removing the keyword 'external'."
analyzerCode: ParserErrorCode.EXTERNAL_CLASS
script:
- "external class C {}"
ExternalEnum:
index: 5
template: "Enums can't be declared to be 'external'."
tip: "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
template: "An external or native method can't have a body."
analyzerCode: EXTERNAL_METHOD_WITH_BODY
script:
- "class C {external foo() {}}"
- "class C {foo() native {}}"
- "class C {foo() native 'bar' {}}"
ExternalTypedef:
template: "Typedefs can't be declared to be 'external'."
tip: "Try removing the keyword 'external'."
analyzerCode: EXTERNAL_TYPEDEF
script:
- "external typedef F();"
OperatorWithOptionalFormals:
template: "An operator can't have optional parameters."
PlatformPrivateLibraryAccess:
template: "Can't access platform private library."
analyzerCode: IMPORT_INTERNAL_LIBRARY
TypedefNotFunction:
template: "Can't create typedef from non-function type."
analyzerCode: INVALID_GENERIC_FUNCTION_TYPE
LibraryDirectiveNotFirst:
template: "The library directive must appear before all other directives."
tip: "Try moving the library directive before any other directives."
analyzerCode: LIBRARY_DIRECTIVE_NOT_FIRST
script:
- "class Foo{} library l;"
- "import 'x.dart'; library l;"
- "part 'a.dart'; library l;"
ImportAfterPart:
index: 10
template: "Import directives must preceed part directives."
tip: "Try moving the import directives before the part directives."
analyzerCode: ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE
script:
- "part 'foo.dart'; import 'bar.dart';"
ExportAfterPart:
template: "Export directives must preceed part directives."
tip: "Try moving the export directives before the part directives."
analyzerCode: EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE
script:
- "part 'foo.dart'; export 'bar.dart';"
DirectiveAfterDeclaration:
template: "Directives must appear before any declarations."
tip: "Try moving the directive before any declarations."
analyzerCode: DIRECTIVE_AFTER_DECLARATION
script:
- "class foo { } import 'bar.dart';"
- "class foo { } export 'bar.dart';"
NonPartOfDirectiveInPart:
template: "The part-of directive must be the only directive in a part."
tip: "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:
template: "Only one part-of directive may be declared in a file."
tip: "Try removing all but one of the part-of directives."
analyzerCode: MULTIPLE_PART_OF_DIRECTIVES
script:
- "part of l; part of m;"
PartTwice:
template: "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:
template: "A file can't be part of more than one library."
tip: "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:
template: "Used as a part in this library."
severity: CONTEXT
FactoryTopLevelDeclaration:
template: "Top-level declarations can't be declared to be 'factory'."
tip: "Try removing the keyword 'factory'."
analyzerCode: FACTORY_TOP_LEVEL_DECLARATION
script:
- "factory class C {}"
RedirectionInNonFactory:
template: "Only factory constructor can specify '=' redirection."
tip: "Try making this a factory constructor, or remove the redirection."
analyzerCode: REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR
script:
- "class C { C() = D; }"
TopLevelOperator:
index: 14
template: "Operators must be declared within a class."
tip: "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:
template: "A function declaration needs an explicit list of parameters."
tip: "Try adding a parameter list to the function declaration."
analyzerCode: MISSING_FUNCTION_PARAMETERS
script:
- "void f {}"
MissingMethodParameters:
template: "A method declaration needs an explicit list of parameters."
tip: "Try adding a parameter list to the method declaration."
analyzerCode: MISSING_METHOD_PARAMETERS
script:
- "class C { void m {} }"
MissingTypedefParameters:
template: "A typedef needs an explicit list of parameters."
tip: "Try adding a parameter list to the typedef."
analyzerCode: MISSING_TYPEDEF_PARAMETERS
script:
- "typedef void F;"
MissingPartOf:
template: "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:
template: "Can't import '#uri', because it has a 'part of' declaration."
tip: "Try removing the 'part of' declaration, or using '#uri' as a part."
analyzerCode: IMPORT_OF_NON_LIBRARY
script:
part.dart: "part of mainlib;"
main.dart: "library mainlib; import 'part.dart';"
SupertypeIsFunction:
template: "Can't use a function type as supertype."
DeferredPrefixDuplicated:
template: "Can't use the name '#name' for a deferred library, as the name is used elsewhere."
analyzerCode: SHARED_DEFERRED_PREFIX
DeferredPrefixDuplicatedCause:
template: "'#name' is used here."
severity: CONTEXT
TypeArgumentsOnTypeVariable:
index: 13
template: "Can't use type arguments with type variable '#name'."
tip: "Try removing the type arguments."
severity: ERROR_LEGACY_WARNING
analyzerCode: ParserErrorCode.TYPE_ARGUMENTS_ON_TYPE_VARIABLE
script:
- "dynamic<T>(x) => 0"
DuplicatedDefinition:
template: "Duplicated definition of '#name'."
DuplicatedName:
template: "'#name' is already declared in this scope."
analyzerCode: DUPLICATE_DEFINITION
DuplicatedNameCause:
template: "Previous declaration of '#name'."
severity: CONTEXT
DuplicatedNamePreviouslyUsed:
template: "Can't declare '#name' because it was already used in this scope."
analyzerCode: REFERENCED_BEFORE_DECLARATION
script:
- "main(arguments) { arguments; var arguments; }"
DuplicatedNamePreviouslyUsedCause:
template: "Previous use of '#name'."
severity: CONTEXT
DuplicatedNamedArgument:
template: "Duplicated named argument '#name'."
analyzerCode: DUPLICATE_NAMED_ARGUMENT
DuplicatedParameterName:
template: "Duplicated parameter name '#name'."
analyzerCode: DUPLICATE_DEFINITION
DuplicatedParameterNameCause:
template: "Other parameter named '#name'."
severity: CONTEXT
MemberWithSameNameAsClass:
template: "A class member can't have the same name as the enclosing class."
EnumConstantSameNameAsEnclosing:
template: "Name of enum constant '#name' can't be the same as the enum's own name."
analyzerCode: ENUM_CONSTANT_WITH_ENUM_NAME
MissingOperatorKeyword:
template: "Operator declarations must be preceeded by the keyword 'operator'."
tip: "Try adding the keyword 'operator'."
analyzerCode: MISSING_KEYWORD_OPERATOR
script:
- "class C { +(x) {} }"
InvalidOperator:
template: "The string '#lexeme' isn't a user-definable operator."
analyzerCode: INVALID_OPERATOR
script:
- "class C { void operator %=(x) {} }"
OperatorParameterMismatch0:
template: "Operator '#name' shouldn't have any parameters."
OperatorParameterMismatch1:
template: "Operator '#name' should have exactly one parameter."
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
OperatorParameterMismatch2:
template: "Operator '#name' should have exactly two parameters."
analyzerCode: WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
OperatorMinusParameterMismatch:
template: "Operator '#name' should have zero or one parameter."
tip: >-
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:
template: "The type '#name' can't be used as supertype."
analyzerCode: EXTENDS_NON_CLASS
SupertypeIsTypeVariable:
template: "The type variable '#name' can't be used as supertype."
analyzerCode: EXTENDS_NON_CLASS
PartOfLibraryNameMismatch:
template: "Using '#uri' as part of '#name' but its 'part of' declaration says '#name2'."
analyzerCode: PART_OF_DIFFERENT_LIBRARY
severity: ERROR_LEGACY_WARNING
PartOfUseUri:
template: "Using '#uri' as part of '#uri2' but its 'part of' declaration says '#name'."
tip: "Try changing the 'part of' declaration to use a relative file name."
analyzerCode: PART_OF_UNNAMED_LIBRARY
severity: ERROR_LEGACY_WARNING
PartOfUriMismatch:
template: "Using '#uri' as part of '#uri2' but its 'part of' declaration says '#uri3'."
analyzerCode: PART_OF_DIFFERENT_LIBRARY
severity: ERROR_LEGACY_WARNING
MissingMain:
template: "No 'main' method found."
tip: "Try adding a method named 'main' to your program."
MissingInput:
template: "No input file provided to the compiler."
InputFileNotFound:
template: "Input file not found: #uri."
SdkRootNotFound:
template: "SDK root directory not found: #uri."
SdkSummaryNotFound:
template: "SDK summary not found: #uri."
SdkSpecificationNotFound:
template: "SDK libraries specification not found: #uri."
tip: "Normally, the specification is a file named 'libraries.json' in the Dart SDK install location."
ThisAccessInFieldInitializer:
template: "Can't access 'this' in a field initializer to read '#name'."
analyzerCode: THIS_ACCESS_FROM_INITIALIZER
ThisOrSuperAccessInFieldInitializer:
template: "Can't access '#string' in a field initializer."
analyzerCode: THIS_ACCESS_FROM_INITIALIZER
ThisAsIdentifier:
template: "Expected identifier, but got 'this'."
analyzerCode: INVALID_REFERENCE_TO_THIS
SuperAsIdentifier:
template: "Expected identifier, but got 'super'."
analyzerCode: SUPER_AS_EXPRESSION
SuperAsExpression:
template: "Can't use 'super' as an expression."
tip: "To delegate a constructor to a super constructor, put the super call as an initializer."
analyzerCode: SUPER_AS_EXPRESSION
SwitchExpressionNotAssignable:
template: "Type '#type' of the switch expression isn't assignable to the type '#type2' of this case expression."
analyzerCode: SWITCH_EXPRESSION_NOT_ASSIGNABLE
script:
- >-
void f() {
switch (42) {
case "foo": break;
}
}
SwitchExpressionNotAssignableCause:
template: "The switch expression is here."
severity: CONTEXT
SwitchHasCaseAfterDefault:
index: 16
template: "The default case should be the last case in a switch statement."
tip: "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
template: "The 'default' case can only be declared once."
tip: "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:
template: "Switch case may fall through to the next case."
severity: ERROR_LEGACY_WARNING
analyzerCode: CASE_BLOCK_NOT_TERMINATED
FinalInstanceVariableAlreadyInitialized:
template: "'#name' is a final instance variable that has already been initialized."
severity: ERROR_LEGACY_WARNING
analyzerCode: FINAL_INITIALIZED_MULTIPLE_TIMES
FinalInstanceVariableAlreadyInitializedCause:
template: "'#name' was initialized here."
severity: CONTEXT
TypeVariableInStaticContext:
template: "Type variables can't be used in static members."
severity: ERROR_LEGACY_WARNING
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:
template: "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>[null];
}
}
- |
class C<T> {
instanceMethod() {
return const <List<T>>[null];
}
}
SuperclassMethodArgumentMismatch:
template: "Superclass doesn't have a method named '#name' with matching arguments."
severity: ERROR_LEGACY_WARNING
SuperclassHasNoGetter:
template: "Superclass has no getter named '#name'."
analyzerCode: UNDEFINED_SUPER_GETTER
severity: ERROR_LEGACY_WARNING
SuperclassHasNoSetter:
template: "Superclass has no setter named '#name'."
analyzerCode: UNDEFINED_SUPER_SETTER
severity: ERROR_LEGACY_WARNING
SuperclassHasNoMethod:
template: "Superclass has no method named '#name'."
severity: ERROR_LEGACY_WARNING
analyzerCode: UNDEFINED_SUPER_METHOD
SuperclassHasNoDefaultConstructor:
template: "The superclass, '#name', has no unnamed constructor that takes no arguments."
analyzerCode: NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
ConstConstructorNonFinalField:
template: "Constructor is marked 'const' so all fields must be final."
analyzerCode: CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD
ConstConstructorNonFinalFieldCause:
template: "Field isn't final, but constructor is 'const'."
severity: CONTEXT
ConstConstructorInSubclassOfMixinApplication:
template: "Can't extend a mixin application and be 'const'."
analyzerCode: CONST_CONSTRUCTOR_IN_SUBCLASS_OF_MIXIN_APPLICATION
ConstConstructorRedirectionToNonConst:
template: "A constant constructor can't call a non-constant constructor."
script:
- >-
class A {
const A.foo() : this.bar();
A.bar() {}
}
AccessError:
template: "Access error: '#name'."
ExpressionNotMetadata:
template: "This can't be used as metadata; metadata should be a reference to a compile-time constant variable, or a call to a constant constructor."
ExpectedAnInitializer:
template: "Expected an initializer."
analyzerCode: MISSING_INITIALIZER
script:
- "class C { C() : {} }"
MissingAssignmentInInitializer:
template: "Expected an assignment after the field name."
tip: "To initialize a field, use the syntax 'name = value'."
analyzerCode: MISSING_ASSIGNMENT_IN_INITIALIZER
script:
- "class C { C() : x(3) {} }"
RedirectingConstructorWithBody:
template: "Redirecting constructors can't have a body."
tip: "Try removing the body, or not making this a redirecting constructor."
analyzerCode: REDIRECTING_CONSTRUCTOR_WITH_BODY
script:
- "class C { C() : this.x() {} }"
CannotAssignToParenthesizedExpression:
template: "Can't assign to a parenthesized expression."
analyzerCode: ASSIGNMENT_TO_PARENTHESIZED_EXPRESSION
NotAnLvalue:
template: "Can't assign to this."
analyzerCode: NOT_AN_LVALUE
CannotAssignToSuper:
template: "Can't assign to super."
analyzerCode: NOT_AN_LVALUE
IllegalAssignmentToNonAssignable:
template: "Illegal assignment to non-assignable expression."
analyzerCode: ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE
script:
- "main(){ f()++; }"
MissingAssignableSelector:
template: "Missing selector such as '.<identifier>' or '[0]'."
tip: "Try adding a selector."
analyzerCode: MISSING_ASSIGNABLE_SELECTOR
script:
- "main(){ ++f(); }"
CannotReadSdkSpecification:
template: "Unable to read the 'libraries.json' specification file:\n #string."
CantInferPackagesFromManyInputs:
template: "Can't infer a .packages file when compiling multiple inputs."
tip: "Try specifying the file explicitly with the --packages option."
CantInferPackagesFromPackageUri:
template: "Can't infer a .packages file from an input 'package:*' URI."
tip: "Try specifying the file explicitly with the --packages option."
PackageNotFound:
template: "Could not resolve the package '#name' in '#uri'."
InvalidPackageUri:
template: "Invalid package URI '#uri':\n #string."
CouldNotParseUri:
template: "Couldn't parse URI '#string':\n #string2."
ExpectedUri:
template: "Expected a URI."
InterpolationInUri:
template: "Can't use string interpolation in a URI."
analyzerCode: INVALID_LITERAL_IN_CONFIGURATION
IntegerLiteralIsOutOfRange:
template: "The integer literal #lexeme can't be represented in 64 bits."
tip: "Try using the BigInt class if you need an integer larger than 9,223,372,036,854,775,807 or less than -9,223,372,036,854,775,808."
analyzerCode: INTEGER_LITERAL_OUT_OF_RANGE
ColonInPlaceOfIn:
template: "For-in loops use 'in' rather than a colon."
tip: "Try replacing the colon with the keyword 'in'."
analyzerCode: COLON_IN_PLACE_OF_IN
ExternalFactoryRedirection:
template: "A redirecting factory can't be external."
tip: "Try removing the 'external' modifier."
analyzerCode: EXTERNAL_CONSTRUCTOR_WITH_BODY
ArgumentTypeNotAssignable:
template: "The argument type '#type' can't be assigned to the parameter type '#type2'."
tip: "Try changing the type of the parameter, or casting the argument to '#type2'."
analyzerCode: ARGUMENT_TYPE_NOT_ASSIGNABLE
InvalidAssignment:
template: "A value of type '#type' can't be assigned to a variable of type '#type2'."
tip: "Try changing the type of the left hand side, or casting the right hand side to '#type2'."
analyzerCode: INVALID_ASSIGNMENT
script: >
main() {
int i;
i = 1.5;
}
PatchClassTypeVariablesMismatch:
template: "A patch class must have the same number of type variables as its origin class."
PatchClassOrigin:
template: "This is the origin class."
severity: CONTEXT
PatchDeclarationMismatch:
template: "This patch doesn't match origin declaration."
PatchDeclarationOrigin:
template: "This is the origin declaration."
severity: CONTEXT
PatchInjectionFailed:
template: "Can't inject '#name' into '#uri'."
tip: "Try adding '@patch'."
PatchNonExternal:
template: "Can't apply this patch as its origin declaration isn't external."
tip: "Try adding 'external' to the origin declaration."
InvalidCastFunctionExpr:
template: "The function expression type '#type' isn't of expected type '#type2'."
tip: "Change the type of the function expression or the context in which it is used."
analyzerCode: INVALID_CAST_FUNCTION_EXPR
InvalidCastLiteralList:
template: "The list literal type '#type' isn't of expected type '#type2'."
tip: "Change the type of the list literal or the context in which it is used."
analyzerCode: INVALID_CAST_LITERAL_LIST
InvalidCastLiteralMap:
template: "The map literal type '#type' isn't of expected type '#type2'."
tip: "Change the type of the map literal or the context in which it is used."
analyzerCode: INVALID_CAST_LITERAL_MAP
InvalidCastLocalFunction:
template: "The local function has type '#type' that isn't of expected type '#type2'."
tip: "Change the type of the function or the context in which it is used."
analyzerCode: INVALID_CAST_FUNCTION
InvalidCastNewExpr:
template: "The constructor returns type '#type' that isn't of expected type '#type2'."
tip: "Change the type of the object being constructed or the context in which it is used."
analyzerCode: INVALID_CAST_NEW_EXPR
InvalidCastStaticMethod:
template: "The static method has type '#type' that isn't of expected type '#type2'."
tip: "Change the type of the method or the context in which it is used."
analyzerCode: INVALID_CAST_METHOD
InvalidCastTopLevelFunction:
template: "The top level function has type '#type' that isn't of expected type '#type2'."
tip: "Change the type of the function or the context in which it is used."
analyzerCode: INVALID_CAST_FUNCTION
InvalidCatchArguments:
template: "Invalid catch arguments."
analyzerCode: INVALID_CATCH_ARGUMENTS
InvalidUseOfNullAwareAccess:
template: "Cannot use '?.' here."
tip: "Try using '.'."
analyzerCode: INVALID_USE_OF_NULL_AWARE_ACCESS
UndefinedGetter:
template: "The getter '#name' isn't defined for the class '#type'."
tip: "Try correcting the name to the name of an existing getter, or defining a getter or field named '#name'."
analyzerCode: UNDEFINED_GETTER
script: >
class C {}
main() {
C c;
print(c.foo);
}
UndefinedSetter:
template: "The setter '#name' isn't defined for the class '#type'."
tip: "Try correcting the name to the name of an existing setter, or defining a setter or field named '#name'."
analyzerCode: UNDEFINED_SETTER
script: >
class C {}
main() {
C c;
c.foo = 0;
}
UndefinedMethod:
template: "The method '#name' isn't defined for the class '#type'."
tip: "Try correcting the name to the name of an existing method, or defining a method named '#name'."
analyzerCode: UNDEFINED_METHOD
script: >
class C {}
main() {
C c;
c.foo();
}
SourceOutlineSummary:
template: |
Built outlines for #count compilation units (#count2 bytes) in #num1%.3ms, that is,
#num2%12.3 bytes/ms, and
#num3%12.3 ms/compilation unit.
SourceBodySummary:
template: |
Built bodies for #count compilation units (#count2 bytes) in #num1%.3ms, that is,
#num2%12.3 bytes/ms, and
#num3%12.3 ms/compilation unit.
DillOutlineSummary:
template: |
Indexed #count libraries (#count2 bytes) in #num1%.3ms, that is,
#num2%12.3 bytes/ms, and
#num3%12.3 ms/libraries.
CantInferTypeDueToInconsistentOverrides:
template: "Can't infer the type of '#string': overridden members must all have the same type."
tip: "Specify the type explicitly."
analyzerCode: INVALID_METHOD_OVERRIDE
CantInferTypeDueToCircularity:
template: "Can't infer the type of '#string': circularity found during type inference."
tip: "Specify the type explicitly."
analyzerCode: RECURSIVE_COMPILE_TIME_CONSTANT
AmbiguousSupertypes:
template: "'#name' can't implement both '#type' and '#type2'"
analyzerCode: AMBIGUOUS_SUPERTYPES
CantUseSuperBoundedTypeForInstanceCreation:
template: "Can't use a super-bounded type for instance creation. Got '#type'."
tip: "Specify a regular-bounded type instead of the super-bounded type. Note that the latter may be due to type inference."
MixinInferenceNoMatchingClass:
template: "Type parameters could not be inferred for the mixin '#name' because '#name2' does not implement the mixin's supertype constraint '#type'."
analyzerCode: MIXIN_INFERENCE_NO_POSSIBLE_SUBSTITUTION
ImplicitCallOfNonMethod:
template: "Cannot invoke an instance of '#type' because it declares 'call' to be something other than a method."
tip: "Try changing 'call' to a method or explicitly invoke 'call'."
analyzerCode: IMPLICIT_CALL_OF_NON_METHOD
ExpectedOneExpression:
template: "Expected one expression, but found additional input."
ForInLoopNotAssignable:
template: "Can't assign to this, so it can't be used in a for-in loop."
statement: "for (1 in []) {}"
ForInLoopExactlyOneVariable:
template: "A for-in loop can't have more than one loop variable."
statement: "for (var x, y in []) {}"
ForInLoopWithConstVariable:
template: "A for-in loop-variable can't be 'const'."
tip: "Try removing the 'const' modifier."
analyzerCode: FOR_IN_WITH_CONST_VARIABLE
ForInLoopElementTypeNotAssignable:
template: "A value of type '#type' can't be assigned to a variable of type '#type2'."
tip: "Try changing the type of the variable."
analyzerCode: FOR_IN_OF_INVALID_ELEMENT_TYPE
ForInLoopTypeNotIterable:
template: "The type '#type' used in the 'for' loop must implement '#type2'."
analyzerCode: FOR_IN_OF_INVALID_TYPE
InitializingFormalTypeMismatch:
template: "The type of parameter '#name' (#type) is not a subtype of the corresponding field's type (#type2)."
tip: "Try changing the type of parameter '#name' to a subtype of #type2."
severity: ERROR_LEGACY_WARNING
analyzerCode: INVALID_PARAMETER_DECLARATION
script: >
class C {
int x;
C(num this.x);
}
InitializingFormalTypeMismatchField:
template: "The field that corresponds to the parameter."
severity: CONTEXT
UseOfDeprecatedIdentifier:
template: "'#name' is deprecated."
severity: IGNORED
InitializeFromDillNotSelfContained:
template: "Tried to initialize from a previous compilation (#string), but the file was not self-contained. This might be a bug. The Dart team would greatly appreciate if you would take a moment to report this problem at http://dartbug.com/new."
severity: WARNING
frontendInternal: true
external: test/incremental_load_from_invalid_dill_test.dart
InitializeFromDillUnknownProblem:
template: "Tried to initialize from a previous compilation (#string), but couldn't. Error message was '#string2'. This might be a bug. The Dart team would greatly appreciate if you would take a moment to report this problem at http://dartbug.com/new."
severity: WARNING
frontendInternal: true
external: test/incremental_load_from_invalid_dill_test.dart
MissingExplicitTypeArguments:
template: "No type arguments provided, #count possible."
severity: IGNORED
WebLiteralCannotBeRepresentedExactly:
template: "The integer literal #string can't be represented exactly in JavaScript."
tip: "Try changing the literal to something that can be represented in Javascript. In Javascript #string2 is the nearest value that can be represented exactly."
BoundIssueViaRawTypeWithNonSimpleBounds:
template: "Generic type '#name' can't be used without type arguments in a type variable bound."
tip: "Try providing type arguments to '#name' here."
analyzerCode: NOT_INSTANTIATED_BOUND
script: >
class Hest<X extends Hest<X>> {}
class Fisk<Y extends Hest> {}
NonSimpleBoundViaVariable:
template: "Bound of this variable references variable '#name' from the same declaration."
severity: CONTEXT
BoundIssueViaLoopNonSimplicity:
template: "Generic type '#name' can't be used without type arguments in the bounds of its own type variables."
tip: "Try providing type arguments to '#name' here."
analyzerCode: NOT_INSTANTIATED_BOUND
script: >
class Hest<X extends Hest> {}
BoundIssueViaCycleNonSimplicity:
template: "Generic type '#name' can't be used without type arguments in the bounds of its own type variables. It is referenced indirectly through '#name2'."
tip: "Try providing type arguments to '#name2' here or to some other raw types in the bounds along the reference chain."
analyzerCode: NOT_INSTANTIATED_BOUND
script: >
class Hest<X extends Fisk> {}
class Fisk<Y extends Hest> {}
NonSimpleBoundViaReference:
template: "Bound of this variable references raw type '#name'."
severity: CONTEXT
CycleInTypeVariables:
template: "Type '#name' is a bound of itself via '#string'."
tip: "Try breaking the cycle by removing at least on of the 'extends' clauses in the cycle."
analyzerCode: TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND
script:
- "foo<A extends A>() {}"
CantUsePrefixAsExpression:
template: "A prefix can't be used as an expression."
analyzerCode: PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT
script: |
import "dart:core" as prefix;
main() {
for (prefix in []) {}
}
CantUsePrefixWithNullAware:
template: "A prefix can't be used with null-aware operators."
tip: "It should be safe to remove the '?' as a prefix is never null."
analyzerCode: PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT
script: |
import "dart:core" as prefix;
main() {
prefix?.Object;
}
CantUseDeferredPrefixAsConstant:
template: >
'#lexeme' can't be used in a constant expression because it's marked as
'deferred' which means it isn't available until loaded.
tip: >
Try moving the constant from the deferred library, or removing 'deferred'
from the import.
analyzerCode: CONST_DEFERRED_CLASS
script: |
import "dart:core" deferred as prefix;
main() {
const prefix.Object();
}
CyclicRedirectingFactoryConstructors:
template: "Cyclic definition of factory '#name'."
analyzerCode: RECURSIVE_FACTORY_REDIRECT
script: |
class Foo {
factory Foo.foo() = Foo.bar;
factory Foo.bar() = Foo.foo;
}
main() { var foo = new Foo.foo(); }
GenericFunctionTypeInBound:
template: "Type variables can't have generic function types in their bounds."
analyzerCode: GENERIC_FUNCTION_TYPE_CANNOT_BE_BOUND
script: |
class Hest<X extends Y Function<Y>(Y)> {}
VoidExpression:
template: "This expression has type 'void' and can't be used."
analyzerCode: USE_OF_VOID_RESULT
statement: |
{
void x;
int y = x;
}
ReturnFromVoidFunction:
template: "Can't return a value from a void function."
analyzerCode: RETURN_OF_INVALID_TYPE
declaration: "void foo() { return 1; }"
ReturnWithoutExpression:
template: "Must explicitly return a value from a non-void function."
severity: WARNING
analyzerCode: RETURN_WITHOUT_VALUE
declaration: "int foo() { return; }"
RethrowNotCatch:
template: "'rethrow' can only be used in catch clauses."
analyzerCode: RETHROW_OUTSIDE_CATCH
InvokeNonFunction:
template: "'#name' isn't a function or method and can't be invoked."
analyzerCode: INVOCATION_OF_NON_FUNCTION
script: |
class Foo {
int f;
}
main() {
Foo foo = new Foo();
foo.f();
}
ConstInstanceField:
template: "Only static fields can be declared as const."
tip: "Try using 'final' instead of 'const', or adding the keyword 'static'."
analyzerCode: CONST_INSTANCE_FIELD
script:
- "class C { const field = 0; }"
DefaultValueInRedirectingFactoryConstructor:
template: "Can't have a default value here because any default values of '#name' would be used instead."
tip: "Try removing the default value."
analyzerCode: DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR
script:
- >-
class A {
factory A.f({int x = 42}) = A.g;
A.g() {}
}
UntranslatableUri:
template: "Not found: '#uri'"
analyzerCode: URI_DOES_NOT_EXIST
script: |
import "dart:non_existing_library";
main() {
}
CantReadFile:
template: "Error when reading '#uri': #string"
analyzerCode: URI_DOES_NOT_EXIST
external: test/packages_format_error_test.dart
script: |
import "non_existing_file.dart";
main() {
}
PackagesFileFormat:
template: "Problem in packages configuration file: #string"
external: test/packages_format_error_test.dart