CodeMirror: Linter Demo

Linter Demo

Errors: 0

Warnings: 1

File: /home/fstrocco/Dart/dart/benchmark/analyzer/lib/src/generated/error.dart

// Copyright (c) 2014, 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. library engine.error; import 'dart:collection'; import 'ast.dart' show AstNode; import 'element.dart'; import 'java_core.dart'; import 'scanner.dart' show Token; import 'source.dart'; /** * An error discovered during the analysis of some Dart code. * * See [AnalysisErrorListener]. */ class AnalysisError { /** * An empty array of errors used when no errors are expected. */ static const List<AnalysisError> NO_ERRORS = const <AnalysisError>[]; /** * A [Comparator] that sorts by the name of the file that the [AnalysisError] * was found. */ static Comparator<AnalysisError> FILE_COMPARATOR = (AnalysisError o1, AnalysisError o2) => o1.source.shortName.compareTo(o2.source.shortName); /** * A [Comparator] that sorts error codes first by their severity (errors * first, warnings second), and then by the the error code type. */ static Comparator<AnalysisError> ERROR_CODE_COMPARATOR = (AnalysisError o1, AnalysisError o2) { ErrorCode errorCode1 = o1.errorCode; ErrorCode errorCode2 = o2.errorCode; ErrorSeverity errorSeverity1 = errorCode1.errorSeverity; ErrorSeverity errorSeverity2 = errorCode2.errorSeverity; ErrorType errorType1 = errorCode1.type; ErrorType errorType2 = errorCode2.type; if (errorSeverity1 == errorSeverity2) { return errorType1.compareTo(errorType2); } else { return errorSeverity2.compareTo(errorSeverity1); } }; /** * The error code associated with the error. */ final ErrorCode errorCode; /** * The localized error message. */ String _message; /** * The correction to be displayed for this error, or `null` if there is no * correction information for this error. */ String _correction; /** * The source in which the error occurred, or `null` if unknown. */ Source source; /** * The character offset from the beginning of the source (zero based) where * the error occurred. */ int offset = 0; /** * The number of characters from the offset to the end of the source which * encompasses the compilation error. */ int _length = 0; /** * A flag indicating whether this error can be shown to be a non-issue because * of the result of type propagation. */ bool isStaticOnly = false; /** * Initialize a newly created analysis error for the specified [source]. The * error will have the given [errorCode] and the list of [arguments] will be * used to complete the message. The error has no location information. */ AnalysisError.con1(this.source, this.errorCode, [List<Object> arguments]) { this._message = formatList(errorCode.message, arguments); } /** * Initialize a newly created analysis error for the specified [source] at the * given [offset] with the given [length]. The error will have the given * [errorCode] and the list of [arguments] will be used to complete the * message. */ AnalysisError.con2(this.source, this.offset, int length, this.errorCode, [List<Object> arguments]) { this._length = length; this._message = formatList(errorCode.message, arguments); String correctionTemplate = errorCode.correction; if (correctionTemplate != null) { this._correction = formatList(correctionTemplate, arguments); } } /** * Return the template used to create the correction to be displayed for this * error, or `null` if there is no correction information for this error. The * correction should indicate how the user can fix the error. */ String get correction => _correction; @override int get hashCode { int hashCode = offset; hashCode ^= (_message != null) ? _message.hashCode : 0; hashCode ^= (source != null) ? source.hashCode : 0; return hashCode; } /** * Return the length of the error location, that is, the number of characters * from the offset to the end of the source which encompasses the compilation * error. */ int get length => _length; /** * Return the message to be displayed for this error. The message should * indicate what is wrong and why it is wrong. */ String get message => _message; @override bool operator ==(Object obj) { if (identical(obj, this)) { return true; } // prepare other AnalysisError if (obj is! AnalysisError) { return false; } AnalysisError other = obj as AnalysisError; // Quick checks. if (!identical(errorCode, other.errorCode)) { return false; } if (offset != other.offset || _length != other._length) { return false; } if (isStaticOnly != other.isStaticOnly) { return false; } // Deep checks. if (_message != other._message) { return false; } if (source != other.source) { return false; } // OK return true; } /** * Return the value of the given [property], or `null` if the given property * is not defined for this error. */ Object getProperty(ErrorProperty property) => null; @override String toString() { StringBuffer buffer = new StringBuffer(); buffer.write((source != null) ? source.fullName : "<unknown source>"); buffer.write("("); buffer.write(offset); buffer.write(".."); buffer.write(offset + _length - 1); buffer.write("): "); //buffer.write("(" + lineNumber + ":" + columnNumber + "): "); buffer.write(_message); return buffer.toString(); } } /** * An object that listen for [AnalysisError]s being produced by the analysis * engine. */ abstract class AnalysisErrorListener { /** * An error listener that ignores errors that are reported to it. */ static final AnalysisErrorListener NULL_LISTENER = new AnalysisErrorListener_NULL_LISTENER(); /** * This method is invoked when an [error] has been found by the analysis * engine. */ void onError(AnalysisError error); } /** * An [AnalysisErrorListener] that ignores error. */ class AnalysisErrorListener_NULL_LISTENER implements AnalysisErrorListener { @override void onError(AnalysisError event) { // Ignore errors } } /** * An [AnalysisError] that can have arbitrary properties associated with it. */ class AnalysisErrorWithProperties extends AnalysisError { /** * The properties associated with this error. */ HashMap<ErrorProperty, Object> _propertyMap = new HashMap<ErrorProperty, Object>(); /** * Initialize a newly created analysis error for the specified [source]. The * error will have the given [errorCode] and the list of [arguments] will be * used to complete the message. The error has no location information. */ AnalysisErrorWithProperties.con1(Source source, ErrorCode errorCode, [List<Object> arguments]) : super.con1(source, errorCode, arguments); /** * Initialize a newly created analysis error for the specified [source] at the * given [offset] with the given [length]. The error will have the given * [errorCode] and the list of [arguments] will be used to complete the * message. */ AnalysisErrorWithProperties.con2( Source source, int offset, int length, ErrorCode errorCode, [List<Object> arguments]) : super.con2(source, offset, length, errorCode, arguments); @override Object getProperty(ErrorProperty property) => _propertyMap[property]; /** * Set the value of the given [property] to the given [value]. Using a value * of `null` will effectively remove the property from this error. */ void setProperty(ErrorProperty property, Object value) { _propertyMap[property] = value; } } /** * An [AnalysisErrorListener] that keeps track of whether any error has been * reported to it. */ class BooleanErrorListener implements AnalysisErrorListener { /** * A flag indicating whether an error has been reported to this listener. */ bool _errorReported = false; /** * Return `true` if an error has been reported to this listener. */ bool get errorReported => _errorReported; @override void onError(AnalysisError error) { _errorReported = true; } } /** * The error codes used for compile time errors caused by constant evaluation * that would throw an exception when run in checked mode. The client of the * analysis engine is responsible for determining how these errors should be * presented to the user (for example, a command-line compiler might elect to * treat these errors differently depending whether it is compiling it "checked" * mode). */ class CheckedModeCompileTimeErrorCode extends ErrorCode { // TODO(paulberry): improve the text of these error messages so that it's // clear to the user that the error is coming from constant evaluation (and // hence the constant needs to be a subtype of the annotated type) as opposed // to static type analysis (which only requires that the two types be // assignable). Also consider populating the "correction" field for these // errors. /** * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. */ static const CheckedModeCompileTimeErrorCode CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH = const CheckedModeCompileTimeErrorCode( 'CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH', "The object type '{0}' cannot be assigned to the field '{1}', which has type '{2}'"); /** * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. */ static const CheckedModeCompileTimeErrorCode CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH = const CheckedModeCompileTimeErrorCode( 'CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH', "The object type '{0}' cannot be assigned to a parameter of type '{1}'"); /** * 7.6.1 Generative Constructors: In checked mode, it is a dynamic type error * if o is not null and the interface of the class of o is not a * subtype of the static type of the field v. * * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. * * Parameters: * 0: the name of the type of the initializer expression * 1: the name of the type of the field */ static const CheckedModeCompileTimeErrorCode CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE = const CheckedModeCompileTimeErrorCode( 'CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE', "The initializer type '{0}' cannot be assigned to the field type '{1}'"); /** * 12.6 Lists: A run-time list literal <E> [e1 * ... en] is evaluated as follows: * * The operator []= is invoked on a with first argument i and * second argument oi+1, 1 <= i <= n * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, * 1 <= j <= m. */ static const CheckedModeCompileTimeErrorCode LIST_ELEMENT_TYPE_NOT_ASSIGNABLE = const CheckedModeCompileTimeErrorCode('LIST_ELEMENT_TYPE_NOT_ASSIGNABLE', "The element type '{0}' cannot be assigned to the list type '{1}'"); /** * 12.7 Map: A run-time map literal <K, V> * [k1 : e1 ... kn : * en] is evaluated as follows: * * The operator []= is invoked on m with first argument * ki and second argument ei, 1 <= * i <= n * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. */ static const CheckedModeCompileTimeErrorCode MAP_KEY_TYPE_NOT_ASSIGNABLE = const CheckedModeCompileTimeErrorCode('MAP_KEY_TYPE_NOT_ASSIGNABLE', "The element type '{0}' cannot be assigned to the map key type '{1}'"); /** * 12.7 Map: A run-time map literal <K, V> * [k1 : e1 ... kn : * en] is evaluated as follows: * * The operator []= is invoked on m with first argument * ki and second argument ei, 1 <= * i <= n * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. */ static const CheckedModeCompileTimeErrorCode MAP_VALUE_TYPE_NOT_ASSIGNABLE = const CheckedModeCompileTimeErrorCode('MAP_VALUE_TYPE_NOT_ASSIGNABLE', "The element type '{0}' cannot be assigned to the map value type '{1}'"); /** * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. */ static const CheckedModeCompileTimeErrorCode VARIABLE_TYPE_MISMATCH = const CheckedModeCompileTimeErrorCode('VARIABLE_TYPE_MISMATCH', "The object type '{0}' cannot be assigned to a variable of type '{1}'"); /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const CheckedModeCompileTimeErrorCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorType.CHECKED_MODE_COMPILE_TIME_ERROR.severity; @override ErrorType get type => ErrorType.CHECKED_MODE_COMPILE_TIME_ERROR; } /** * The error codes used for compile time errors. The convention for this class * is for the name of the error code to indicate the problem that caused the * error to be generated and for the error message to explain what is wrong and, * when appropriate, how the problem can be corrected. */ class CompileTimeErrorCode extends ErrorCode { /** * Enum proposal: It is also a compile-time error to explicitly instantiate an * enum via 'new' or 'const' or to access its private fields. */ static const CompileTimeErrorCode ACCESS_PRIVATE_ENUM_FIELD = const CompileTimeErrorCode('ACCESS_PRIVATE_ENUM_FIELD', "The private fields of an enum cannot be accessed, even within the same library"); /** * 14.2 Exports: It is a compile-time error if a name N is re-exported * by a library L and N is introduced into the export namespace * of L by more than one export, unless each all exports refer to same * declaration for the name N. * * Parameters: * 0: the name of the ambiguous element * 1: the name of the first library that the type is found * 2: the name of the second library that the type is found */ static const CompileTimeErrorCode AMBIGUOUS_EXPORT = const CompileTimeErrorCode('AMBIGUOUS_EXPORT', "The name '{0}' is defined in the libraries '{1}' and '{2}'"); /** * 12.33 Argument Definition Test: It is a compile time error if v does * not denote a formal parameter. * * Parameters: * 0: the name of the identifier in the argument definition test that is not a * parameter */ static const CompileTimeErrorCode ARGUMENT_DEFINITION_TEST_NON_PARAMETER = const CompileTimeErrorCode( 'ARGUMENT_DEFINITION_TEST_NON_PARAMETER', "'{0}' is not a parameter"); /** * ?? Asynchronous For-in: It is a compile-time error if an asynchronous * for-in statement appears inside a synchronous function. */ static const CompileTimeErrorCode ASYNC_FOR_IN_WRONG_CONTEXT = const CompileTimeErrorCode('ASYNC_FOR_IN_WRONG_CONTEXT', "The asynchronous for-in can only be used in a function marked with async or async*"); /** * ??: It is a compile-time error if the function immediately enclosing a is * not declared asynchronous. */ static const CompileTimeErrorCode AWAIT_IN_WRONG_CONTEXT = const CompileTimeErrorCode('AWAIT_IN_WRONG_CONTEXT', "The await expression can only be used in a function marked as async or async*"); /** * 12.30 Identifier Reference: It is a compile-time error to use a built-in * identifier other than dynamic as a type annotation. */ static const CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPE = const CompileTimeErrorCode('BUILT_IN_IDENTIFIER_AS_TYPE', "The built-in identifier '{0}' cannot be as a type"); /** * 12.30 Identifier Reference: It is a compile-time error if a built-in * identifier is used as the declared name of a class, type parameter or type * alias. */ static const CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPE_NAME = const CompileTimeErrorCode('BUILT_IN_IDENTIFIER_AS_TYPE_NAME', "The built-in identifier '{0}' cannot be used as a type name"); /** * 12.30 Identifier Reference: It is a compile-time error if a built-in * identifier is used as the declared name of a class, type parameter or type * alias. */ static const CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME = const CompileTimeErrorCode('BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME', "The built-in identifier '{0}' cannot be used as a type alias name"); /** * 12.30 Identifier Reference: It is a compile-time error if a built-in * identifier is used as the declared name of a class, type parameter or type * alias. */ static const CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME = const CompileTimeErrorCode('BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME', "The built-in identifier '{0}' cannot be used as a type parameter name"); /** * 13.9 Switch: It is a compile-time error if the class C implements * the operator ==. */ static const CompileTimeErrorCode CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS = const CompileTimeErrorCode('CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS', "The switch case expression type '{0}' cannot override the == operator"); /** * 12.1 Constants: It is a compile-time error if evaluation of a compile-time * constant would raise * an exception. */ static const CompileTimeErrorCode COMPILE_TIME_CONSTANT_RAISES_EXCEPTION = const CompileTimeErrorCode('COMPILE_TIME_CONSTANT_RAISES_EXCEPTION', ""); /** * 7.2 Getters: It is a compile-time error if a class has both a getter and a * method with the same name. This restriction holds regardless of whether the * getter is defined explicitly or implicitly, or whether the getter or the * method are inherited or not. */ static const CompileTimeErrorCode CONFLICTING_GETTER_AND_METHOD = const CompileTimeErrorCode('CONFLICTING_GETTER_AND_METHOD', "Class '{0}' cannot have both getter '{1}.{2}' and method with the same name"); /** * 7.2 Getters: It is a compile-time error if a class has both a getter and a * method with the same name. This restriction holds regardless of whether the * getter is defined explicitly or implicitly, or whether the getter or the * method are inherited or not. */ static const CompileTimeErrorCode CONFLICTING_METHOD_AND_GETTER = const CompileTimeErrorCode('CONFLICTING_METHOD_AND_GETTER', "Class '{0}' cannot have both method '{1}.{2}' and getter with the same name"); /** * 7.6 Constructors: A constructor name always begins with the name of its * immediately enclosing class, and may optionally be followed by a dot and an * identifier id. It is a compile-time error if id is the name * of a member declared in the immediately enclosing class. */ static const CompileTimeErrorCode CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD = const CompileTimeErrorCode('CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD', "'{0}' cannot be used to name a constructor and a field in this class"); /** * 7.6 Constructors: A constructor name always begins with the name of its * immediately enclosing class, and may optionally be followed by a dot and an * identifier id. It is a compile-time error if id is the name * of a member declared in the immediately enclosing class. */ static const CompileTimeErrorCode CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD = const CompileTimeErrorCode('CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD', "'{0}' cannot be used to name a constructor and a method in this class"); /** * 7. Classes: It is a compile time error if a generic class declares a type * variable with the same name as the class or any of its members or * constructors. */ static const CompileTimeErrorCode CONFLICTING_TYPE_VARIABLE_AND_CLASS = const CompileTimeErrorCode('CONFLICTING_TYPE_VARIABLE_AND_CLASS', "'{0}' cannot be used to name a type varaible in a class with the same name"); /** * 7. Classes: It is a compile time error if a generic class declares a type * variable with the same name as the class or any of its members or * constructors. */ static const CompileTimeErrorCode CONFLICTING_TYPE_VARIABLE_AND_MEMBER = const CompileTimeErrorCode('CONFLICTING_TYPE_VARIABLE_AND_MEMBER', "'{0}' cannot be used to name a type varaible and member in this class"); /** * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. */ static const CompileTimeErrorCode CONST_CONSTRUCTOR_THROWS_EXCEPTION = const CompileTimeErrorCode('CONST_CONSTRUCTOR_THROWS_EXCEPTION', "'const' constructors cannot throw exceptions"); /** * 10.6.3 Constant Constructors: It is a compile-time error if a constant * constructor is declared by a class C if any instance variable declared in C * is initialized with an expression that is not a constant expression. */ static const CompileTimeErrorCode CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST = const CompileTimeErrorCode( 'CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST', "Can't define the 'const' constructor because the field '{0}' is initialized with a non-constant value"); /** * 7.6.3 Constant Constructors: The superinitializer that appears, explicitly * or implicitly, in the initializer list of a constant constructor must * specify a constant constructor of the superclass of the immediately * enclosing class or a compile-time error occurs. * * 9 Mixins: For each generative constructor named ... an implicitly declared * constructor named ... is declared. */ static const CompileTimeErrorCode CONST_CONSTRUCTOR_WITH_MIXIN = const CompileTimeErrorCode('CONST_CONSTRUCTOR_WITH_MIXIN', "Constant constructor cannot be declared for a class with a mixin"); /** * 7.6.3 Constant Constructors: The superinitializer that appears, explicitly * or implicitly, in the initializer list of a constant constructor must * specify a constant constructor of the superclass of the immediately * enclosing class or a compile-time error occurs. */ static const CompileTimeErrorCode CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER = const CompileTimeErrorCode('CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER', "Constant constructor cannot call non-constant super constructor of '{0}'"); /** * 7.6.3 Constant Constructors: It is a compile-time error if a constant * constructor is declared by a class that has a non-final instance variable. * * The above refers to both locally declared and inherited instance variables. */ static const CompileTimeErrorCode CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD = const CompileTimeErrorCode('CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD', "Cannot define the 'const' constructor for a class with non-final fields"); /** * 12.12.2 Const: It is a compile-time error if T is a deferred type. */ static const CompileTimeErrorCode CONST_DEFERRED_CLASS = const CompileTimeErrorCode('CONST_DEFERRED_CLASS', "Deferred classes cannot be created with 'const'"); /** * 6.2 Formal Parameters: It is a compile-time error if a formal parameter is * declared as a constant variable. */ static const CompileTimeErrorCode CONST_FORMAL_PARAMETER = const CompileTimeErrorCode( 'CONST_FORMAL_PARAMETER', "Parameters cannot be 'const'"); /** * 5 Variables: A constant variable must be initialized to a compile-time * constant or a compile-time error occurs. */ static const CompileTimeErrorCode CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE = const CompileTimeErrorCode('CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE', "'const' variables must be constant value"); /** * 5 Variables: A constant variable must be initialized to a compile-time * constant or a compile-time error occurs. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode( 'CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used to initialized a 'const' variable"); /** * 7.5 Instance Variables: It is a compile-time error if an instance variable * is declared to be constant. */ static const CompileTimeErrorCode CONST_INSTANCE_FIELD = const CompileTimeErrorCode('CONST_INSTANCE_FIELD', "Only static fields can be declared as 'const'"); /** * 12.8 Maps: It is a compile-time error if the key of an entry in a constant * map literal is an instance of a class that implements the operator * == unless the key is a string or integer. */ static const CompileTimeErrorCode CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS = const CompileTimeErrorCode( 'CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS', "The constant map entry key expression type '{0}' cannot override the == operator"); /** * 5 Variables: A constant variable must be initialized to a compile-time * constant (12.1) or a compile-time error occurs. * * Parameters: * 0: the name of the uninitialized final variable */ static const CompileTimeErrorCode CONST_NOT_INITIALIZED = const CompileTimeErrorCode('CONST_NOT_INITIALIZED', "The const variable '{0}' must be initialized"); /** * 12.11.2 Const: An expression of one of the forms !e, e1 && e2 or e1 || e2, * where e, e1 and e2 are constant expressions that evaluate to a boolean * value. */ static const CompileTimeErrorCode CONST_EVAL_TYPE_BOOL = const CompileTimeErrorCode('CONST_EVAL_TYPE_BOOL', "In constant expressions, operand(s) of this operator must be of type 'bool'"); /** * 12.11.2 Const: An expression of one of the forms e1 == e2 or e1 != e2 where * e1 and e2 are constant expressions that evaluate to a numeric, string or * boolean value or to null. */ static const CompileTimeErrorCode CONST_EVAL_TYPE_BOOL_NUM_STRING = const CompileTimeErrorCode('CONST_EVAL_TYPE_BOOL_NUM_STRING', "In constant expressions, operands of this operator must be of type 'bool', 'num', 'String' or 'null'"); /** * 12.11.2 Const: An expression of one of the forms ~e, e1 ^ e2, e1 & e2, * e1 | e2, e1 >> e2 or e1 << e2, where e, e1 and e2 are constant expressions * that evaluate to an integer value or to null. */ static const CompileTimeErrorCode CONST_EVAL_TYPE_INT = const CompileTimeErrorCode('CONST_EVAL_TYPE_INT', "In constant expressions, operand(s) of this operator must be of type 'int'"); /** * 12.11.2 Const: An expression of one of the forms e, e1 + e2, e1 - e2, e1 * * e2, e1 / e2, e1 ~/ e2, e1 > e2, e1 < e2, e1 >= e2, e1 <= e2 or e1 % e2, * where e, e1 and e2 are constant expressions that evaluate to a numeric * value or to null. */ static const CompileTimeErrorCode CONST_EVAL_TYPE_NUM = const CompileTimeErrorCode('CONST_EVAL_TYPE_NUM', "In constant expressions, operand(s) of this operator must be of type 'num'"); /** * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. */ static const CompileTimeErrorCode CONST_EVAL_THROWS_EXCEPTION = const CompileTimeErrorCode('CONST_EVAL_THROWS_EXCEPTION', "Evaluation of this constant expression causes exception"); /** * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. */ static const CompileTimeErrorCode CONST_EVAL_THROWS_IDBZE = const CompileTimeErrorCode('CONST_EVAL_THROWS_IDBZE', "Evaluation of this constant expression throws IntegerDivisionByZeroException"); /** * 12.11.2 Const: If T is a parameterized type S<U1, * …, Um>, let R = S; It is a compile time * error if S is not a generic type with m type parameters. * * Parameters: * 0: the name of the type being referenced (S) * 1: the number of type parameters that were declared * 2: the number of type arguments provided * * See [CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS], and * [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]. */ static const CompileTimeErrorCode CONST_WITH_INVALID_TYPE_PARAMETERS = const CompileTimeErrorCode('CONST_WITH_INVALID_TYPE_PARAMETERS', "The type '{0}' is declared with {1} type parameters, but {2} type arguments were given"); /** * 12.11.2 Const: If e is of the form const T(a1, * …, an, xn+1: an+1, …, * xn+k: an+k) it is a compile-time error if the * type T does not declare a constant constructor with the same name as * the declaration of T. */ static const CompileTimeErrorCode CONST_WITH_NON_CONST = const CompileTimeErrorCode('CONST_WITH_NON_CONST', "The constructor being called is not a 'const' constructor"); /** * 12.11.2 Const: In all of the above cases, it is a compile-time error if * ai, 1 <= i <= n + k, is not a compile-time constant * expression. */ static const CompileTimeErrorCode CONST_WITH_NON_CONSTANT_ARGUMENT = const CompileTimeErrorCode('CONST_WITH_NON_CONSTANT_ARGUMENT', "Arguments of a constant creation must be constant expressions"); /** * 12.11.2 Const: It is a compile-time error if T is not a class * accessible in the current scope, optionally followed by type arguments. * * 12.11.2 Const: If e is of the form const T.id(a1, * …, an, xn+1: an+1, … * xn+k: an+k) it is a compile-time error if * T is not a class accessible in the current scope, optionally * followed by type arguments. * * Parameters: * 0: the name of the non-type element */ static const CompileTimeErrorCode CONST_WITH_NON_TYPE = const CompileTimeErrorCode( 'CONST_WITH_NON_TYPE', "The name '{0}' is not a class"); /** * 12.11.2 Const: It is a compile-time error if T includes any type * parameters. */ static const CompileTimeErrorCode CONST_WITH_TYPE_PARAMETERS = const CompileTimeErrorCode('CONST_WITH_TYPE_PARAMETERS', "The constant creation cannot use a type parameter"); /** * 12.11.2 Const: It is a compile-time error if T.id is not the name of * a constant constructor declared by the type T. * * Parameters: * 0: the name of the type * 1: the name of the requested constant constructor */ static const CompileTimeErrorCode CONST_WITH_UNDEFINED_CONSTRUCTOR = const CompileTimeErrorCode('CONST_WITH_UNDEFINED_CONSTRUCTOR', "The class '{0}' does not have a constant constructor '{1}'"); /** * 12.11.2 Const: It is a compile-time error if T.id is not the name of * a constant constructor declared by the type T. * * Parameters: * 0: the name of the type */ static const CompileTimeErrorCode CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT = const CompileTimeErrorCode('CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT', "The class '{0}' does not have a default constant constructor"); /** * 15.3.1 Typedef: It is a compile-time error if any default values are * specified in the signature of a function type alias. */ static const CompileTimeErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS = const CompileTimeErrorCode('DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS', "Default values aren't allowed in typedefs"); /** * 6.2.1 Required Formals: By means of a function signature that names the * parameter and describes its type as a function type. It is a compile-time * error if any default values are specified in the signature of such a * function type. */ static const CompileTimeErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER = const CompileTimeErrorCode('DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER', "Default values aren't allowed in function type parameters"); /** * 7.6.2 Factories: It is a compile-time error if k explicitly * specifies a default value for an optional parameter. */ static const CompileTimeErrorCode DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR = const CompileTimeErrorCode( 'DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR', "Default values aren't allowed in factory constructors that redirect to another constructor"); /** * 3.1 Scoping: It is a compile-time error if there is more than one entity * with the same name declared in the same scope. */ static const CompileTimeErrorCode DUPLICATE_CONSTRUCTOR_DEFAULT = const CompileTimeErrorCode('DUPLICATE_CONSTRUCTOR_DEFAULT', "The default constructor is already defined"); /** * 3.1 Scoping: It is a compile-time error if there is more than one entity * with the same name declared in the same scope. * * Parameters: * 0: the name of the duplicate entity */ static const CompileTimeErrorCode DUPLICATE_CONSTRUCTOR_NAME = const CompileTimeErrorCode('DUPLICATE_CONSTRUCTOR_NAME', "The constructor with name '{0}' is already defined"); /** * 3.1 Scoping: It is a compile-time error if there is more than one entity * with the same name declared in the same scope. * * 7 Classes: It is a compile-time error if a class declares two members of * the same name. * * 7 Classes: It is a compile-time error if a class has an instance member and * a static member with the same name. * * Parameters: * 0: the name of the duplicate entity */ static const CompileTimeErrorCode DUPLICATE_DEFINITION = const CompileTimeErrorCode( 'DUPLICATE_DEFINITION', "The name '{0}' is already defined"); /** * 7. Classes: It is a compile-time error if a class has an instance member * and a static member with the same name. * * This covers the additional duplicate definition cases where inheritance has * to be considered. * * Parameters: * 0: the name of the class that has conflicting instance/static members * 1: the name of the conflicting members * * See [DUPLICATE_DEFINITION]. */ static const CompileTimeErrorCode DUPLICATE_DEFINITION_INHERITANCE = const CompileTimeErrorCode('DUPLICATE_DEFINITION_INHERITANCE', "The name '{0}' is already defined in '{1}'"); /** * 12.14.2 Binding Actuals to Formals: It is a compile-time error if * qi = qj for any i != j [where * qi is the label for a named argument]. */ static const CompileTimeErrorCode DUPLICATE_NAMED_ARGUMENT = const CompileTimeErrorCode('DUPLICATE_NAMED_ARGUMENT', "The argument for the named parameter '{0}' was already specified"); /** * SDK implementation libraries can be exported only by other SDK libraries. * * Parameters: * 0: the uri pointing to a library */ static const CompileTimeErrorCode EXPORT_INTERNAL_LIBRARY = const CompileTimeErrorCode('EXPORT_INTERNAL_LIBRARY', "The library '{0}' is internal and cannot be exported"); /** * 14.2 Exports: It is a compile-time error if the compilation unit found at * the specified URI is not a library declaration. * * Parameters: * 0: the uri pointing to a non-library declaration */ static const CompileTimeErrorCode EXPORT_OF_NON_LIBRARY = const CompileTimeErrorCode('EXPORT_OF_NON_LIBRARY', "The exported library '{0}' must not have a part-of directive"); /** * Enum proposal: It is a compile-time error to subclass, mix-in or implement * an enum. */ static const CompileTimeErrorCode EXTENDS_ENUM = const CompileTimeErrorCode( 'EXTENDS_ENUM', "Classes cannot extend an enum"); /** * 7.9 Superclasses: It is a compile-time error if the extends clause of a * class C includes a type expression that does not denote a class * available in the lexical scope of C. * * Parameters: * 0: the name of the superclass that was not found */ static const CompileTimeErrorCode EXTENDS_NON_CLASS = const CompileTimeErrorCode( 'EXTENDS_NON_CLASS', "Classes can only extend other classes"); /** * 12.2 Null: It is a compile-time error for a class to attempt to extend or * implement Null. * * 12.3 Numbers: It is a compile-time error for a class to attempt to extend * or implement int. * * 12.3 Numbers: It is a compile-time error for a class to attempt to extend * or implement double. * * 12.3 Numbers: It is a compile-time error for any type other than the types * int and double to * attempt to extend or implement num. * * 12.4 Booleans: It is a compile-time error for a class to attempt to extend * or implement bool. * * 12.5 Strings: It is a compile-time error for a class to attempt to extend * or implement String. * * Parameters: * 0: the name of the type that cannot be extended * * See [IMPLEMENTS_DISALLOWED_CLASS]. */ static const CompileTimeErrorCode EXTENDS_DISALLOWED_CLASS = const CompileTimeErrorCode( 'EXTENDS_DISALLOWED_CLASS', "Classes cannot extend '{0}'"); /** * 7.9 Superclasses: It is a compile-time error if the extends clause of a * class C includes a deferred type expression. * * Parameters: * 0: the name of the type that cannot be extended * * See [IMPLEMENTS_DEFERRED_CLASS], and [MIXIN_DEFERRED_CLASS]. */ static const CompileTimeErrorCode EXTENDS_DEFERRED_CLASS = const CompileTimeErrorCode('EXTENDS_DEFERRED_CLASS', "This class cannot extend the deferred class '{0}'"); /** * 12.14.2 Binding Actuals to Formals: It is a static warning if m < * h or if m > n. * * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. * * Parameters: * 0: the maximum number of positional arguments * 1: the actual number of positional arguments given */ static const CompileTimeErrorCode EXTRA_POSITIONAL_ARGUMENTS = const CompileTimeErrorCode('EXTRA_POSITIONAL_ARGUMENTS', "{0} positional arguments expected, but {1} found"); /** * 7.6.1 Generative Constructors: Let k be a generative constructor. It * is a compile time error if more than one initializer corresponding to a * given instance variable appears in k's list. */ static const CompileTimeErrorCode FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS = const CompileTimeErrorCode('FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS', "The field '{0}' cannot be initialized twice in the same constructor"); /** * 7.6.1 Generative Constructors: Let k be a generative constructor. It * is a compile time error if k's initializer list contains an * initializer for a variable that is initialized by means of an initializing * formal of k. */ static const CompileTimeErrorCode FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER = const CompileTimeErrorCode( 'FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER', "Fields cannot be initialized in both the parameter list and the initializers"); /** * 5 Variables: It is a compile-time error if a final instance variable that * has is initialized by means of an initializing formal of a constructor is * also initialized elsewhere in the same constructor. * * Parameters: * 0: the name of the field in question */ static const CompileTimeErrorCode FINAL_INITIALIZED_MULTIPLE_TIMES = const CompileTimeErrorCode('FINAL_INITIALIZED_MULTIPLE_TIMES', "'{0}' is a final field and so can only be set once"); /** * 7.6.1 Generative Constructors: It is a compile-time error if an * initializing formal is used by a function other than a non-redirecting * generative constructor. */ static const CompileTimeErrorCode FIELD_INITIALIZER_FACTORY_CONSTRUCTOR = const CompileTimeErrorCode('FIELD_INITIALIZER_FACTORY_CONSTRUCTOR', "Initializing formal fields cannot be used in factory constructors"); /** * 7.6.1 Generative Constructors: It is a compile-time error if an * initializing formal is used by a function other than a non-redirecting * generative constructor. */ static const CompileTimeErrorCode FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR = const CompileTimeErrorCode('FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR', "Initializing formal fields can only be used in constructors"); /** * 7.6.1 Generative Constructors: A generative constructor may be redirecting, * in which case its only action is to invoke another generative constructor. * * 7.6.1 Generative Constructors: It is a compile-time error if an * initializing formal is used by a function other than a non-redirecting * generative constructor. */ static const CompileTimeErrorCode FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR = const CompileTimeErrorCode('FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR', "The redirecting constructor cannot have a field initializer"); /** * 7.2 Getters: It is a compile-time error if a class has both a getter and a * method with the same name. * * Parameters: * 0: the conflicting name of the getter and method */ static const CompileTimeErrorCode GETTER_AND_METHOD_WITH_SAME_NAME = const CompileTimeErrorCode('GETTER_AND_METHOD_WITH_SAME_NAME', "'{0}' cannot be used to name a getter, there is already a method with the same name"); /** * 7.10 Superinterfaces: It is a compile-time error if the implements clause * of a class C specifies a malformed type or deferred type as a * superinterface. * * Parameters: * 0: the name of the type that cannot be extended * * See [EXTENDS_DEFERRED_CLASS], and [MIXIN_DEFERRED_CLASS]. */ static const CompileTimeErrorCode IMPLEMENTS_DEFERRED_CLASS = const CompileTimeErrorCode('IMPLEMENTS_DEFERRED_CLASS', "This class cannot implement the deferred class '{0}'"); /** * 12.2 Null: It is a compile-time error for a class to attempt to extend or * implement Null. * * 12.3 Numbers: It is a compile-time error for a class to attempt to extend * or implement int. * * 12.3 Numbers: It is a compile-time error for a class to attempt to extend * or implement double. * * 12.3 Numbers: It is a compile-time error for any type other than the types * int and double to * attempt to extend or implement num. * * 12.4 Booleans: It is a compile-time error for a class to attempt to extend * or implement bool. * * 12.5 Strings: It is a compile-time error for a class to attempt to extend * or implement String. * * Parameters: * 0: the name of the type that cannot be implemented * * See [EXTENDS_DISALLOWED_CLASS]. */ static const CompileTimeErrorCode IMPLEMENTS_DISALLOWED_CLASS = const CompileTimeErrorCode( 'IMPLEMENTS_DISALLOWED_CLASS', "Classes cannot implement '{0}'"); /** * 7.10 Superinterfaces: It is a compile-time error if the implements clause * of a class includes type dynamic. */ static const CompileTimeErrorCode IMPLEMENTS_DYNAMIC = const CompileTimeErrorCode( 'IMPLEMENTS_DYNAMIC', "Classes cannot implement 'dynamic'"); /** * Enum proposal: It is a compile-time error to subclass, mix-in or implement * an enum. */ static const CompileTimeErrorCode IMPLEMENTS_ENUM = const CompileTimeErrorCode( 'IMPLEMENTS_ENUM', "Classes cannot implement an enum"); /** * 7.10 Superinterfaces: It is a compile-time error if the implements clause * of a class C includes a type expression that does not denote a class * available in the lexical scope of C. * * Parameters: * 0: the name of the interface that was not found */ static const CompileTimeErrorCode IMPLEMENTS_NON_CLASS = const CompileTimeErrorCode( 'IMPLEMENTS_NON_CLASS', "Classes can only implement other classes"); /** * 7.10 Superinterfaces: It is a compile-time error if a type T appears * more than once in the implements clause of a class. * * Parameters: * 0: the name of the class that is implemented more than once */ static const CompileTimeErrorCode IMPLEMENTS_REPEATED = const CompileTimeErrorCode( 'IMPLEMENTS_REPEATED', "'{0}' can only be implemented once"); /** * 7.10 Superinterfaces: It is a compile-time error if the superclass of a * class C appears in the implements clause of C. * * Parameters: * 0: the name of the class that appears in both "extends" and "implements" * clauses */ static const CompileTimeErrorCode IMPLEMENTS_SUPER_CLASS = const CompileTimeErrorCode('IMPLEMENTS_SUPER_CLASS', "'{0}' cannot be used in both 'extends' and 'implements' clauses"); /** * 7.6.1 Generative Constructors: Note that this is not in scope on the * right hand side of an initializer. * * 12.10 This: It is a compile-time error if this appears in a top-level * function or variable initializer, in a factory constructor, or in a static * method or variable initializer, or in the initializer of an instance * variable. * * Parameters: * 0: the name of the type in question */ static const CompileTimeErrorCode IMPLICIT_THIS_REFERENCE_IN_INITIALIZER = const CompileTimeErrorCode('IMPLICIT_THIS_REFERENCE_IN_INITIALIZER', "Only static members can be accessed in initializers"); /** * SDK implementation libraries can be imported only by other SDK libraries. * * Parameters: * 0: the uri pointing to a library */ static const CompileTimeErrorCode IMPORT_INTERNAL_LIBRARY = const CompileTimeErrorCode('IMPORT_INTERNAL_LIBRARY', "The library '{0}' is internal and cannot be imported"); /** * 14.1 Imports: It is a compile-time error if the specified URI of an * immediate import does not refer to a library declaration. * * Parameters: * 0: the uri pointing to a non-library declaration * * See [StaticWarningCode.IMPORT_OF_NON_LIBRARY]. */ static const CompileTimeErrorCode IMPORT_OF_NON_LIBRARY = const CompileTimeErrorCode('IMPORT_OF_NON_LIBRARY', "The imported library '{0}' must not have a part-of directive"); /** * 13.9 Switch: It is a compile-time error if values of the expressions * ek are not instances of the same class C, for all * 1 <= k <= n. * * Parameters: * 0: the expression source code that is the unexpected type * 1: the name of the expected type */ static const CompileTimeErrorCode INCONSISTENT_CASE_EXPRESSION_TYPES = const CompileTimeErrorCode('INCONSISTENT_CASE_EXPRESSION_TYPES', "Case expressions must have the same types, '{0}' is not a '{1}'"); /** * 7.6.1 Generative Constructors: Let k be a generative constructor. It * is a compile-time error if k's initializer list contains an * initializer for a variable that is not an instance variable declared in the * immediately surrounding class. * * Parameters: * 0: the name of the initializing formal that is not an instance variable in * the immediately enclosing class * * See [INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]. */ static const CompileTimeErrorCode INITIALIZER_FOR_NON_EXISTENT_FIELD = const CompileTimeErrorCode('INITIALIZER_FOR_NON_EXISTENT_FIELD', "'{0}' is not a variable in the enclosing class"); /** * 7.6.1 Generative Constructors: Let k be a generative constructor. It * is a compile-time error if k's initializer list contains an * initializer for a variable that is not an instance variable declared in the * immediately surrounding class. * * Parameters: * 0: the name of the initializing formal that is a static variable in the * immediately enclosing class * * See [INITIALIZING_FORMAL_FOR_STATIC_FIELD]. */ static const CompileTimeErrorCode INITIALIZER_FOR_STATIC_FIELD = const CompileTimeErrorCode('INITIALIZER_FOR_STATIC_FIELD', "'{0}' is a static variable in the enclosing class, variables initialized in a constructor cannot be static"); /** * 7.6.1 Generative Constructors: An initializing formal has the form * this.id. It is a compile-time error if id is not the name of * an instance variable of the immediately enclosing class. * * Parameters: * 0: the name of the initializing formal that is not an instance variable in * the immediately enclosing class * * See [INITIALIZING_FORMAL_FOR_STATIC_FIELD], and * [INITIALIZER_FOR_NON_EXISTENT_FIELD]. */ static const CompileTimeErrorCode INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD = const CompileTimeErrorCode('INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD', "'{0}' is not a variable in the enclosing class"); /** * 7.6.1 Generative Constructors: An initializing formal has the form * this.id. It is a compile-time error if id is not the name of * an instance variable of the immediately enclosing class. * * Parameters: * 0: the name of the initializing formal that is a static variable in the * immediately enclosing class * * See [INITIALIZER_FOR_STATIC_FIELD]. */ static const CompileTimeErrorCode INITIALIZING_FORMAL_FOR_STATIC_FIELD = const CompileTimeErrorCode('INITIALIZING_FORMAL_FOR_STATIC_FIELD', "'{0}' is a static field in the enclosing class, fields initialized in a constructor cannot be static"); /** * 12.30 Identifier Reference: Otherwise, e is equivalent to the property * extraction this.id. */ static const CompileTimeErrorCode INSTANCE_MEMBER_ACCESS_FROM_FACTORY = const CompileTimeErrorCode('INSTANCE_MEMBER_ACCESS_FROM_FACTORY', "Instance members cannot be accessed from a factory constructor"); /** * 12.30 Identifier Reference: Otherwise, e is equivalent to the property * extraction this.id. */ static const CompileTimeErrorCode INSTANCE_MEMBER_ACCESS_FROM_STATIC = const CompileTimeErrorCode('INSTANCE_MEMBER_ACCESS_FROM_STATIC', "Instance members cannot be accessed from a static method"); /** * Enum proposal: It is also a compile-time error to explicitly instantiate an * enum via 'new' or 'const' or to access its private fields. */ static const CompileTimeErrorCode INSTANTIATE_ENUM = const CompileTimeErrorCode( 'INSTANTIATE_ENUM', "Enums cannot be instantiated"); /** * 11 Metadata: Metadata consists of a series of annotations, each of which * begin with the character @, followed by a constant expression that must be * either a reference to a compile-time constant variable, or a call to a * constant constructor. */ static const CompileTimeErrorCode INVALID_ANNOTATION = const CompileTimeErrorCode( 'INVALID_ANNOTATION', "Annotation can be only constant variable or constant constructor invocation"); /** * 11 Metadata: Metadata consists of a series of annotations, each of which * begin with the character @, followed by a constant expression that must be * either a reference to a compile-time constant variable, or a call to a * constant constructor. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode('INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as annotations"); /** * 15.31 Identifier Reference: It is a compile-time error if any of the * identifiers async, await or yield is used as an identifier in a function * body marked with either async, async* or sync*. */ static const CompileTimeErrorCode INVALID_IDENTIFIER_IN_ASYNC = const CompileTimeErrorCode('INVALID_IDENTIFIER_IN_ASYNC', "The identifier '{0}' cannot be used in a function marked with async, async* or sync*"); /** * 9. Functions: It is a compile-time error if an async, async* or sync* * modifier is attached to the body of a setter or constructor. */ static const CompileTimeErrorCode INVALID_MODIFIER_ON_CONSTRUCTOR = const CompileTimeErrorCode('INVALID_MODIFIER_ON_CONSTRUCTOR', "The modifier '{0}' cannot be applied to the body of a constructor"); /** * 9. Functions: It is a compile-time error if an async, async* or sync* * modifier is attached to the body of a setter or constructor. */ static const CompileTimeErrorCode INVALID_MODIFIER_ON_SETTER = const CompileTimeErrorCode('INVALID_MODIFIER_ON_SETTER', "The modifier '{0}' cannot be applied to the body of a setter"); /** * TODO(brianwilkerson) Remove this when we have decided on how to report * errors in compile-time constants. Until then, this acts as a placeholder * for more informative errors. * * See TODOs in ConstantVisitor */ static const CompileTimeErrorCode INVALID_CONSTANT = const CompileTimeErrorCode('INVALID_CONSTANT', "Invalid constant value"); /** * 7.6 Constructors: It is a compile-time error if the name of a constructor * is not a constructor name. */ static const CompileTimeErrorCode INVALID_CONSTRUCTOR_NAME = const CompileTimeErrorCode( 'INVALID_CONSTRUCTOR_NAME', "Invalid constructor name"); /** * 7.6.2 Factories: It is a compile-time error if M is not the name of * the immediately enclosing class. */ static const CompileTimeErrorCode INVALID_FACTORY_NAME_NOT_A_CLASS = const CompileTimeErrorCode('INVALID_FACTORY_NAME_NOT_A_CLASS', "The name of the immediately enclosing class expected"); /** * 12.10 This: It is a compile-time error if this appears in a top-level * function or variable initializer, in a factory constructor, or in a static * method or variable initializer, or in the initializer of an instance * variable. */ static const CompileTimeErrorCode INVALID_REFERENCE_TO_THIS = const CompileTimeErrorCode('INVALID_REFERENCE_TO_THIS', "Invalid reference to 'this' expression"); /** * 12.6 Lists: It is a compile time error if the type argument of a constant * list literal includes a type parameter. * * Parameters: * 0: the name of the type parameter */ static const CompileTimeErrorCode INVALID_TYPE_ARGUMENT_IN_CONST_LIST = const CompileTimeErrorCode('INVALID_TYPE_ARGUMENT_IN_CONST_LIST', "Constant list literals cannot include a type parameter as a type argument, such as '{0}'"); /** * 12.7 Maps: It is a compile time error if the type arguments of a constant * map literal include a type parameter. * * Parameters: * 0: the name of the type parameter */ static const CompileTimeErrorCode INVALID_TYPE_ARGUMENT_IN_CONST_MAP = const CompileTimeErrorCode('INVALID_TYPE_ARGUMENT_IN_CONST_MAP', "Constant map literals cannot include a type parameter as a type argument, such as '{0}'"); /** * 14.2 Exports: It is a compile-time error if the compilation unit found at * the specified URI is not a library declaration. * * 14.1 Imports: It is a compile-time error if the compilation unit found at * the specified URI is not a library declaration. * * 14.3 Parts: It is a compile time error if the contents of the URI are not a * valid part declaration. * * Parameters: * 0: the URI that is invalid * * See [URI_DOES_NOT_EXIST]. */ static const CompileTimeErrorCode INVALID_URI = const CompileTimeErrorCode('INVALID_URI', "Invalid URI syntax: '{0}'"); /** * 13.13 Break: It is a compile-time error if no such statement * sE exists within the innermost function in which * sb occurs. * * 13.14 Continue: It is a compile-time error if no such statement or case * clause sE exists within the innermost function in which * sc occurs. * * Parameters: * 0: the name of the unresolvable label */ static const CompileTimeErrorCode LABEL_IN_OUTER_SCOPE = const CompileTimeErrorCode('LABEL_IN_OUTER_SCOPE', "Cannot reference label '{0}' declared in an outer method"); /** * 13.13 Break: It is a compile-time error if no such statement * sE exists within the innermost function in which * sb occurs. * * 13.14 Continue: It is a compile-time error if no such statement or case * clause sE exists within the innermost function in which * sc occurs. * * Parameters: * 0: the name of the unresolvable label */ static const CompileTimeErrorCode LABEL_UNDEFINED = const CompileTimeErrorCode( 'LABEL_UNDEFINED', "Cannot reference undefined label '{0}'"); /** * 7 Classes: It is a compile time error if a class C declares a member * with the same name as C. */ static const CompileTimeErrorCode MEMBER_WITH_CLASS_NAME = const CompileTimeErrorCode('MEMBER_WITH_CLASS_NAME', "Class members cannot have the same name as the enclosing class"); /** * 7.2 Getters: It is a compile-time error if a class has both a getter and a * method with the same name. * * Parameters: * 0: the conflicting name of the getter and method */ static const CompileTimeErrorCode METHOD_AND_GETTER_WITH_SAME_NAME = const CompileTimeErrorCode('METHOD_AND_GETTER_WITH_SAME_NAME', "'{0}' cannot be used to name a method, there is already a getter with the same name"); /** * 12.1 Constants: A constant expression is ... a constant list literal. */ static const CompileTimeErrorCode MISSING_CONST_IN_LIST_LITERAL = const CompileTimeErrorCode('MISSING_CONST_IN_LIST_LITERAL', "List literals must be prefixed with 'const' when used as a constant expression"); /** * 12.1 Constants: A constant expression is ... a constant map literal. */ static const CompileTimeErrorCode MISSING_CONST_IN_MAP_LITERAL = const CompileTimeErrorCode('MISSING_CONST_IN_MAP_LITERAL', "Map literals must be prefixed with 'const' when used as a constant expression"); /** * Enum proposal: It is a static warning if all of the following conditions * hold: * * The switch statement does not have a 'default' clause. * * The static type of e is an enumerated typed with elements * id1, …, idn. * * The sets {e1, …, ek} and * {id1, …, idn} are not the * same. * * Parameters: * 0: the name of the constant that is missing */ static const CompileTimeErrorCode MISSING_ENUM_CONSTANT_IN_SWITCH = const CompileTimeErrorCode('MISSING_ENUM_CONSTANT_IN_SWITCH', "Missing case clause for '{0}'", "Add a case clause for the missing constant or add a default clause."); /** * 9 Mixins: It is a compile-time error if a declared or derived mixin * explicitly declares a constructor. * * Parameters: * 0: the name of the mixin that is invalid */ static const CompileTimeErrorCode MIXIN_DECLARES_CONSTRUCTOR = const CompileTimeErrorCode('MIXIN_DECLARES_CONSTRUCTOR', "The class '{0}' cannot be used as a mixin because it declares a constructor"); /** * 9.1 Mixin Application: It is a compile-time error if the with clause of a * mixin application C includes a deferred type expression. * * Parameters: * 0: the name of the type that cannot be extended * * See [EXTENDS_DEFERRED_CLASS], and [IMPLEMENTS_DEFERRED_CLASS]. */ static const CompileTimeErrorCode MIXIN_DEFERRED_CLASS = const CompileTimeErrorCode('MIXIN_DEFERRED_CLASS', "This class cannot mixin the deferred class '{0}'"); /** * Not yet in the spec, but consistent with VM behavior. It is a * compile-time error if all of the constructors of a mixin's base class have * at least one optional parameter (since only constructors that lack * optional parameters can be forwarded to the mixin). See * https://code.google.com/p/dart/issues/detail?id=15101#c4 */ static const CompileTimeErrorCode MIXIN_HAS_NO_CONSTRUCTORS = const CompileTimeErrorCode('MIXIN_HAS_NO_CONSTRUCTORS', "This mixin application is invalid because all of the constructors " "in the base class '{0}' have optional parameters."); /** * 9 Mixins: It is a compile-time error if a mixin is derived from a class * whose superclass is not Object. * * Parameters: * 0: the name of the mixin that is invalid */ static const CompileTimeErrorCode MIXIN_INHERITS_FROM_NOT_OBJECT = const CompileTimeErrorCode('MIXIN_INHERITS_FROM_NOT_OBJECT', "The class '{0}' cannot be used as a mixin because it extends a class other than Object"); /** * 12.2 Null: It is a compile-time error for a class to attempt to extend or * implement Null. * * 12.3 Numbers: It is a compile-time error for a class to attempt to extend * or implement int. * * 12.3 Numbers: It is a compile-time error for a class to attempt to extend * or implement double. * * 12.3 Numbers: It is a compile-time error for any type other than the types * int and double to attempt to extend or implement num. * * 12.4 Booleans: It is a compile-time error for a class to attempt to extend * or implement bool. * * 12.5 Strings: It is a compile-time error for a class to attempt to extend * or implement String. * * Parameters: * 0: the name of the type that cannot be extended * * See [IMPLEMENTS_DISALLOWED_CLASS]. */ static const CompileTimeErrorCode MIXIN_OF_DISALLOWED_CLASS = const CompileTimeErrorCode( 'MIXIN_OF_DISALLOWED_CLASS', "Classes cannot mixin '{0}'"); /** * Enum proposal: It is a compile-time error to subclass, mix-in or implement * an enum. */ static const CompileTimeErrorCode MIXIN_OF_ENUM = const CompileTimeErrorCode( 'MIXIN_OF_ENUM', "Classes cannot mixin an enum"); /** * 9.1 Mixin Application: It is a compile-time error if M does not * denote a class or mixin available in the immediately enclosing scope. */ static const CompileTimeErrorCode MIXIN_OF_NON_CLASS = const CompileTimeErrorCode( 'MIXIN_OF_NON_CLASS', "Classes can only mixin other classes"); /** * 9 Mixins: It is a compile-time error if a declared or derived mixin refers * to super. */ static const CompileTimeErrorCode MIXIN_REFERENCES_SUPER = const CompileTimeErrorCode('MIXIN_REFERENCES_SUPER', "The class '{0}' cannot be used as a mixin because it references 'super'"); /** * 9.1 Mixin Application: It is a compile-time error if S does not * denote a class available in the immediately enclosing scope. */ static const CompileTimeErrorCode MIXIN_WITH_NON_CLASS_SUPERCLASS = const CompileTimeErrorCode('MIXIN_WITH_NON_CLASS_SUPERCLASS', "Mixin can only be applied to class"); /** * 7.6.1 Generative Constructors: A generative constructor may be redirecting, * in which case its only action is to invoke another generative constructor. */ static const CompileTimeErrorCode MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS = const CompileTimeErrorCode('MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS', "Constructor may have at most one 'this' redirection"); /** * 7.6.1 Generative Constructors: Let k be a generative constructor. * Then k may include at most one superinitializer in its initializer * list or a compile time error occurs. */ static const CompileTimeErrorCode MULTIPLE_SUPER_INITIALIZERS = const CompileTimeErrorCode('MULTIPLE_SUPER_INITIALIZERS', "Constructor may have at most one 'super' initializer"); /** * 11 Metadata: Metadata consists of a series of annotations, each of which * begin with the character @, followed by a constant expression that must be * either a reference to a compile-time constant variable, or a call to a * constant constructor. */ static const CompileTimeErrorCode NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS = const CompileTimeErrorCode('NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS', "Annotation creation must have arguments"); /** * 7.6.1 Generative Constructors: If no superinitializer is provided, an * implicit superinitializer of the form super() is added at the end of * k's initializer list, unless the enclosing class is class * Object. * * 7.6.1 Generative constructors. It is a compile-time error if class S * does not declare a generative constructor named S (respectively * S.id) */ static const CompileTimeErrorCode NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT = const CompileTimeErrorCode('NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT', "The class '{0}' does not have a default constructor"); /** * 7.6 Constructors: Iff no constructor is specified for a class C, it * implicitly has a default constructor C() : super() {}, unless * C is class Object. * * 7.6.1 Generative constructors. It is a compile-time error if class S * does not declare a generative constructor named S (respectively * S.id) */ static const CompileTimeErrorCode NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT = const CompileTimeErrorCode('NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT', "The class '{0}' does not have a default constructor"); /** * 13.2 Expression Statements: It is a compile-time error if a non-constant * map literal that has no explicit type arguments appears in a place where a * statement is expected. */ static const CompileTimeErrorCode NON_CONST_MAP_AS_EXPRESSION_STATEMENT = const CompileTimeErrorCode('NON_CONST_MAP_AS_EXPRESSION_STATEMENT', "A non-constant map literal without type arguments cannot be used as an expression statement"); /** * 13.9 Switch: Given a switch statement of the form switch (e) { * label11 … label1j1 case e1: * s1 … labeln1 … labelnjn case * en: sn default: sn+1} or the form * switch (e) { label11 … label1j1 case * e1: s1 … labeln1 … * labelnjn case en: sn}, it is a * compile-time error if the expressions ek are not * compile-time constants, for all 1 <= k <= n. */ static const CompileTimeErrorCode NON_CONSTANT_CASE_EXPRESSION = const CompileTimeErrorCode( 'NON_CONSTANT_CASE_EXPRESSION', "Case expressions must be constant"); /** * 13.9 Switch: Given a switch statement of the form switch (e) { * label11 … label1j1 case e1: * s1 … labeln1 … labelnjn case * en: sn default: sn+1} or the form * switch (e) { label11 … label1j1 case * e1: s1 … labeln1 … * labelnjn case en: sn}, it is a * compile-time error if the expressions ek are not * compile-time constants, for all 1 <= k <= n. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode( 'NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as a case expression"); /** * 6.2.2 Optional Formals: It is a compile-time error if the default value of * an optional parameter is not a compile-time constant. */ static const CompileTimeErrorCode NON_CONSTANT_DEFAULT_VALUE = const CompileTimeErrorCode('NON_CONSTANT_DEFAULT_VALUE', "Default values of an optional parameter must be constant"); /** * 6.2.2 Optional Formals: It is a compile-time error if the default value of * an optional parameter is not a compile-time constant. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode( 'NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as a default parameter value"); /** * 12.6 Lists: It is a compile time error if an element of a constant list * literal is not a compile-time constant. */ static const CompileTimeErrorCode NON_CONSTANT_LIST_ELEMENT = const CompileTimeErrorCode('NON_CONSTANT_LIST_ELEMENT', "'const' lists must have all constant values"); /** * 12.6 Lists: It is a compile time error if an element of a constant list * literal is not a compile-time constant. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode( 'NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as values in a 'const' list"); /** * 12.7 Maps: It is a compile time error if either a key or a value of an * entry in a constant map literal is not a compile-time constant. */ static const CompileTimeErrorCode NON_CONSTANT_MAP_KEY = const CompileTimeErrorCode( 'NON_CONSTANT_MAP_KEY', "The keys in a map must be constant"); /** * 12.7 Maps: It is a compile time error if either a key or a value of an * entry in a constant map literal is not a compile-time constant. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode('NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as keys in a map"); /** * 12.7 Maps: It is a compile time error if either a key or a value of an * entry in a constant map literal is not a compile-time constant. */ static const CompileTimeErrorCode NON_CONSTANT_MAP_VALUE = const CompileTimeErrorCode('NON_CONSTANT_MAP_VALUE', "The values in a 'const' map must be constant"); /** * 12.7 Maps: It is a compile time error if either a key or a value of an * entry in a constant map literal is not a compile-time constant. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode('NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as values in a 'const' map"); /** * 11 Metadata: Metadata consists of a series of annotations, each of which * begin with the character @, followed by a constant expression that must be * either a reference to a compile-time constant variable, or a call to a * constant constructor. * * "From deferred library" case is covered by * [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]. */ static const CompileTimeErrorCode NON_CONSTANT_ANNOTATION_CONSTRUCTOR = const CompileTimeErrorCode('NON_CONSTANT_ANNOTATION_CONSTRUCTOR', "Annotation creation can use only 'const' constructor"); /** * 7.6.3 Constant Constructors: Any expression that appears within the * initializer list of a constant constructor must be a potentially constant * expression, or a compile-time error occurs. */ static const CompileTimeErrorCode NON_CONSTANT_VALUE_IN_INITIALIZER = const CompileTimeErrorCode('NON_CONSTANT_VALUE_IN_INITIALIZER', "Initializer expressions in constant constructors must be constants"); /** * 7.6.3 Constant Constructors: Any expression that appears within the * initializer list of a constant constructor must be a potentially constant * expression, or a compile-time error occurs. * * 12.1 Constants: A qualified reference to a static constant variable that is * not qualified by a deferred prefix. */ static const CompileTimeErrorCode NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode( 'NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as constant initializers"); /** * 12.14.2 Binding Actuals to Formals: It is a static warning if m < h * or if m > n. * * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. * * Parameters: * 0: the expected number of required arguments * 1: the actual number of positional arguments given */ static const CompileTimeErrorCode NOT_ENOUGH_REQUIRED_ARGUMENTS = const CompileTimeErrorCode('NOT_ENOUGH_REQUIRED_ARGUMENTS', "{0} required argument(s) expected, but {1} found"); /** * 7.6.1 Generative Constructors: Let C be the class in which the * superinitializer appears and let S be the superclass of C. * Let k be a generative constructor. It is a compile-time error if * class S does not declare a generative constructor named S * (respectively S.id) */ static const CompileTimeErrorCode NON_GENERATIVE_CONSTRUCTOR = const CompileTimeErrorCode('NON_GENERATIVE_CONSTRUCTOR', "The generative constructor '{0}' expected, but factory found"); /** * 7.9 Superclasses: It is a compile-time error to specify an extends clause * for class Object. */ static const CompileTimeErrorCode OBJECT_CANNOT_EXTEND_ANOTHER_CLASS = const CompileTimeErrorCode('OBJECT_CANNOT_EXTEND_ANOTHER_CLASS', ""); /** * 7.1.1 Operators: It is a compile-time error to declare an optional * parameter in an operator. */ static const CompileTimeErrorCode OPTIONAL_PARAMETER_IN_OPERATOR = const CompileTimeErrorCode('OPTIONAL_PARAMETER_IN_OPERATOR', "Optional parameters are not allowed when defining an operator"); /** * 14.3 Parts: It is a compile time error if the contents of the URI are not a * valid part declaration. * * Parameters: * 0: the uri pointing to a non-library declaration */ static const CompileTimeErrorCode PART_OF_NON_PART = const CompileTimeErrorCode('PART_OF_NON_PART', "The included part '{0}' must have a part-of directive"); /** * 14.1 Imports: It is a compile-time error if the current library declares a * top-level member named p. */ static const CompileTimeErrorCode PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER = const CompileTimeErrorCode('PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER', "The name '{0}' is already used as an import prefix and cannot be used to name a top-level element"); /** * 6.2.2 Optional Formals: It is a compile-time error if the name of a named * optional parameter begins with an '_' character. */ static const CompileTimeErrorCode PRIVATE_OPTIONAL_PARAMETER = const CompileTimeErrorCode('PRIVATE_OPTIONAL_PARAMETER', "Named optional parameters cannot start with an underscore"); /** * 12.1 Constants: It is a compile-time error if the value of a compile-time * constant expression depends on itself. */ static const CompileTimeErrorCode RECURSIVE_COMPILE_TIME_CONSTANT = const CompileTimeErrorCode('RECURSIVE_COMPILE_TIME_CONSTANT', ""); /** * 7.6.1 Generative Constructors: A generative constructor may be redirecting, * in which case its only action is to invoke another generative constructor. * * TODO(scheglov) review this later, there are no explicit "it is a * compile-time error" in specification. But it was added to the co19 and * there is same error for factories. * * https://code.google.com/p/dart/issues/detail?id=954 */ static const CompileTimeErrorCode RECURSIVE_CONSTRUCTOR_REDIRECT = const CompileTimeErrorCode('RECURSIVE_CONSTRUCTOR_REDIRECT', "Cycle in redirecting generative constructors"); /** * 7.6.2 Factories: It is a compile-time error if a redirecting factory * constructor redirects to itself, either directly or indirectly via a * sequence of redirections. */ static const CompileTimeErrorCode RECURSIVE_FACTORY_REDIRECT = const CompileTimeErrorCode('RECURSIVE_FACTORY_REDIRECT', "Cycle in redirecting factory constructors"); /** * 7.10 Superinterfaces: It is a compile-time error if the interface of a * class C is a superinterface of itself. * * 8.1 Superinterfaces: It is a compile-time error if an interface is a * superinterface of itself. * * 7.9 Superclasses: It is a compile-time error if a class C is a * superclass of itself. * * Parameters: * 0: the name of the class that implements itself recursively * 1: a string representation of the implements loop */ static const CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE = const CompileTimeErrorCode('RECURSIVE_INTERFACE_INHERITANCE', "'{0}' cannot be a superinterface of itself: {1}"); /** * 7.10 Superinterfaces: It is a compile-time error if the interface of a * class C is a superinterface of itself. * * 8.1 Superinterfaces: It is a compile-time error if an interface is a * superinterface of itself. * * 7.9 Superclasses: It is a compile-time error if a class C is a * superclass of itself. * * Parameters: * 0: the name of the class that implements itself recursively */ static const CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS = const CompileTimeErrorCode( 'RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS', "'{0}' cannot extend itself"); /** * 7.10 Superinterfaces: It is a compile-time error if the interface of a * class C is a superinterface of itself. * * 8.1 Superinterfaces: It is a compile-time error if an interface is a * superinterface of itself. * * 7.9 Superclasses: It is a compile-time error if a class C is a * superclass of itself. * * Parameters: * 0: the name of the class that implements itself recursively */ static const CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS = const CompileTimeErrorCode( 'RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS', "'{0}' cannot implement itself"); /** * 7.10 Superinterfaces: It is a compile-time error if the interface of a * class C is a superinterface of itself. * * 8.1 Superinterfaces: It is a compile-time error if an interface is a * superinterface of itself. * * 7.9 Superclasses: It is a compile-time error if a class C is a * superclass of itself. * * Parameters: * 0: the name of the class that implements itself recursively */ static const CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH = const CompileTimeErrorCode( 'RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH', "'{0}' cannot use itself as a mixin"); /** * 7.6.2 Factories: It is a compile-time error if k is prefixed with * the const modifier but k' is not a constant constructor. */ static const CompileTimeErrorCode REDIRECT_TO_MISSING_CONSTRUCTOR = const CompileTimeErrorCode('REDIRECT_TO_MISSING_CONSTRUCTOR', "The constructor '{0}' could not be found in '{1}'"); /** * 7.6.2 Factories: It is a compile-time error if k is prefixed with * the const modifier but k' is not a constant constructor. */ static const CompileTimeErrorCode REDIRECT_TO_NON_CLASS = const CompileTimeErrorCode('REDIRECT_TO_NON_CLASS', "The name '{0}' is not a type and cannot be used in a redirected constructor"); /** * 7.6.2 Factories: It is a compile-time error if k is prefixed with * the const modifier but k' is not a constant constructor. */ static const CompileTimeErrorCode REDIRECT_TO_NON_CONST_CONSTRUCTOR = const CompileTimeErrorCode('REDIRECT_TO_NON_CONST_CONSTRUCTOR', "Constant factory constructor cannot delegate to a non-constant constructor"); /** * 7.6.1 Generative constructors: A generative constructor may be * redirecting, in which case its only action is to invoke another * generative constructor. */ static const CompileTimeErrorCode REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR = const CompileTimeErrorCode('REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR', "The constructor '{0}' could not be found in '{1}'"); /** * 7.6.1 Generative constructors: A generative constructor may be * redirecting, in which case its only action is to invoke another * generative constructor. */ static const CompileTimeErrorCode REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR = const CompileTimeErrorCode( 'REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR', "Generative constructor cannot redirect to a factory constructor"); /** * 5 Variables: A local variable may only be referenced at a source code * location that is after its initializer, if any, is complete, or a * compile-time error occurs. */ static const CompileTimeErrorCode REFERENCED_BEFORE_DECLARATION = const CompileTimeErrorCode('REFERENCED_BEFORE_DECLARATION', "Local variables cannot be referenced before they are declared"); /** * 12.8.1 Rethrow: It is a compile-time error if an expression of the form * rethrow; is not enclosed within a on-catch clause. */ static const CompileTimeErrorCode RETHROW_OUTSIDE_CATCH = const CompileTimeErrorCode( 'RETHROW_OUTSIDE_CATCH', "rethrow must be inside of a catch clause"); /** * 13.12 Return: It is a compile-time error if a return statement of the form * return e; appears in a generative constructor. */ static const CompileTimeErrorCode RETURN_IN_GENERATIVE_CONSTRUCTOR = const CompileTimeErrorCode('RETURN_IN_GENERATIVE_CONSTRUCTOR', "Constructors cannot return a value"); /** * 13.12 Return: It is a compile-time error if a return statement of the form * return e; appears in a generator function. */ static const CompileTimeErrorCode RETURN_IN_GENERATOR = const CompileTimeErrorCode('RETURN_IN_GENERATOR', "Cannot return a value from a generator function (one marked with either 'async*' or 'sync*')"); /** * 14.1 Imports: It is a compile-time error if a prefix used in a deferred * import is used in another import clause. */ static const CompileTimeErrorCode SHARED_DEFERRED_PREFIX = const CompileTimeErrorCode('SHARED_DEFERRED_PREFIX', "The prefix of a deferred import cannot be used in other import directives"); /** * 12.15.4 Super Invocation: A super method invocation i has the form * super.m(a1, …, an, xn+1: * an+1, … xn+k: an+k). It is a * compile-time error if a super method invocation occurs in a top-level * function or variable initializer, in an instance variable initializer or * initializer list, in class Object, in a factory constructor, or in a static * method or variable initializer. */ static const CompileTimeErrorCode SUPER_IN_INVALID_CONTEXT = const CompileTimeErrorCode( 'SUPER_IN_INVALID_CONTEXT', "Invalid context for 'super' invocation"); /** * 7.6.1 Generative Constructors: A generative constructor may be redirecting, * in which case its only action is to invoke another generative constructor. */ static const CompileTimeErrorCode SUPER_IN_REDIRECTING_CONSTRUCTOR = const CompileTimeErrorCode('SUPER_IN_REDIRECTING_CONSTRUCTOR', "The redirecting constructor cannot have a 'super' initializer"); /** * 7.6.1 Generative Constructors: Let k be a generative constructor. It * is a compile-time error if a generative constructor of class Object * includes a superinitializer. */ static const CompileTimeErrorCode SUPER_INITIALIZER_IN_OBJECT = const CompileTimeErrorCode('SUPER_INITIALIZER_IN_OBJECT', ""); /** * 12.11 Instance Creation: It is a static type warning if any of the type * arguments to a constructor of a generic type G invoked by a new * expression or a constant object expression are not subtypes of the bounds * of the corresponding formal type parameters of G. * * 12.11.1 New: If T is malformed a dynamic error occurs. In checked mode, if * T is mal-bounded a dynamic error occurs. * * 12.1 Constants: It is a compile-time error if evaluation of a compile-time * constant would raise an exception. * * Parameters: * 0: the name of the type used in the instance creation that should be * limited by the bound as specified in the class declaration * 1: the name of the bounding type * * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]. */ static const CompileTimeErrorCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS = const CompileTimeErrorCode( 'TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', "'{0}' does not extend '{1}'"); /** * 15.3.1 Typedef: Any self reference, either directly, or recursively via * another typedef, is a compile time error. */ static const CompileTimeErrorCode TYPE_ALIAS_CANNOT_REFERENCE_ITSELF = const CompileTimeErrorCode('TYPE_ALIAS_CANNOT_REFERENCE_ITSELF', "Type alias cannot reference itself directly or recursively via another typedef"); /** * 12.11.2 Const: It is a compile-time error if T is not a class * accessible in the current scope, optionally followed by type arguments. */ static const CompileTimeErrorCode UNDEFINED_CLASS = const CompileTimeErrorCode('UNDEFINED_CLASS', "Undefined class '{0}'"); /** * 7.6.1 Generative Constructors: Let C be the class in which the * superinitializer appears and let S be the superclass of C. * Let k be a generative constructor. It is a compile-time error if * class S does not declare a generative constructor named S * (respectively S.id) */ static const CompileTimeErrorCode UNDEFINED_CONSTRUCTOR_IN_INITIALIZER = const CompileTimeErrorCode('UNDEFINED_CONSTRUCTOR_IN_INITIALIZER', "The class '{0}' does not have a generative constructor '{1}'"); /** * 7.6.1 Generative Constructors: Let C be the class in which the * superinitializer appears and let S be the superclass of C. * Let k be a generative constructor. It is a compile-time error if * class S does not declare a generative constructor named S * (respectively S.id) */ static const CompileTimeErrorCode UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT = const CompileTimeErrorCode('UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT', "The class '{0}' does not have a default generative constructor"); /** * 12.14.2 Binding Actuals to Formals: Furthermore, each qi, * 1<=i<=l, must have a corresponding named parameter in the set * {pn+1 ... pn+k} or a static warning * occurs. * * 12.11.2 Const: It is a compile-time error if evaluation of a constant * object results in an uncaught exception being thrown. * * Parameters: * 0: the name of the requested named parameter */ static const CompileTimeErrorCode UNDEFINED_NAMED_PARAMETER = const CompileTimeErrorCode('UNDEFINED_NAMED_PARAMETER', "The named parameter '{0}' is not defined"); /** * 14.2 Exports: It is a compile-time error if the compilation unit found at * the specified URI is not a library declaration. * * 14.1 Imports: It is a compile-time error if the compilation unit found at * the specified URI is not a library declaration. * * 14.3 Parts: It is a compile time error if the contents of the URI are not a * valid part declaration. * * Parameters: * 0: the URI pointing to a non-existent file * * See [INVALID_URI]. */ static const CompileTimeErrorCode URI_DOES_NOT_EXIST = const CompileTimeErrorCode( 'URI_DOES_NOT_EXIST', "Target of URI does not exist: '{0}'"); /** * 14.1 Imports: It is a compile-time error if x is not a compile-time * constant, or if x involves string interpolation. * * 14.3 Parts: It is a compile-time error if s is not a compile-time * constant, or if s involves string interpolation. * * 14.5 URIs: It is a compile-time error if the string literal x that * describes a URI is not a compile-time constant, or if x involves * string interpolation. */ static const CompileTimeErrorCode URI_WITH_INTERPOLATION = const CompileTimeErrorCode( 'URI_WITH_INTERPOLATION', "URIs cannot use string interpolation"); /** * 7.1.1 Operators: It is a compile-time error if the arity of the * user-declared operator []= is not 2. It is a compile time error if the * arity of a user-declared operator with one of the names: <, >, <=, * >=, ==, +, /, ~/, *, %, |, ^, &, <<, >>, [] is not 1. It is * a compile time error if the arity of the user-declared operator - is not 0 * or 1. It is a compile time error if the arity of the user-declared operator * ~ is not 0. * * Parameters: * 0: the name of the declared operator * 1: the number of parameters expected * 2: the number of parameters found in the operator declaration */ static const CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR = const CompileTimeErrorCode('WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR', "Operator '{0}' should declare exactly {1} parameter(s), but {2} found"); /** * 7.1.1 Operators: It is a compile time error if the arity of the * user-declared operator - is not 0 or 1. * * Parameters: * 0: the number of parameters found in the operator declaration */ static const CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS = const CompileTimeErrorCode( 'WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS', "Operator '-' should declare 0 or 1 parameter, but {0} found"); /** * 7.3 Setters: It is a compile-time error if a setter's formal parameter list * does not include exactly one required formal parameter p. */ static const CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER = const CompileTimeErrorCode('WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER', "Setters should declare exactly one required parameter"); /** * ?? Yield: It is a compile-time error if a yield statement appears in a * function that is not a generator function. */ static const CompileTimeErrorCode YIELD_EACH_IN_NON_GENERATOR = const CompileTimeErrorCode('YIELD_EACH_IN_NON_GENERATOR', "Yield-each statements must be in a generator function (one marked with either 'async*' or 'sync*')"); /** * ?? Yield: It is a compile-time error if a yield statement appears in a * function that is not a generator function. */ static const CompileTimeErrorCode YIELD_IN_NON_GENERATOR = const CompileTimeErrorCode('YIELD_IN_NON_GENERATOR', "Yield statements must be in a generator function (one marked with either 'async*' or 'sync*')"); /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const CompileTimeErrorCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorType.COMPILE_TIME_ERROR.severity; @override ErrorType get type => ErrorType.COMPILE_TIME_ERROR; } /** * An error code associated with an [AnalysisError]. * * Generally, we want to provide messages that consist of three sentences. From * the user's perspective these sentences should explain: * 1. what is wrong, * 2. why is it wrong, and * 3. how do I fix it. * However, we combine the first two in the [message] and the last in the * [correction]. */ abstract class ErrorCode { /** * An empty list of error codes. */ static const List<ErrorCode> EMPTY_LIST = const <ErrorCode>[]; /** * The name of the error code. */ final String name; /** * The template used to create the message to be displayed for this error. The * message should indicate what is wrong and why it is wrong. */ final String message; /** * The template used to create the correction to be displayed for this error, * or `null` if there is no correction information for this error. The * correction should indicate how the user can fix the error. */ final String correction; /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const ErrorCode(this.name, this.message, [this.correction]); /** * The severity of the error. */ ErrorSeverity get errorSeverity; /** * The type of the error. */ ErrorType get type; /** * The unique name of this error code. */ String get uniqueName => "$runtimeType.$name"; } /** * The properties that can be associated with an [AnalysisError]. */ class ErrorProperty extends Enum<ErrorProperty> { /** * A property whose value is a list of [FieldElement]s that are final, but * not initialized by a constructor. */ static const ErrorProperty NOT_INITIALIZED_FIELDS = const ErrorProperty('NOT_INITIALIZED_FIELDS', 0); /** * A property whose value is the name of the library that is used by all * of the "part of" directives, so should be used in the "library" directive. * Is `null` if there is no a single name used by all of the parts. */ static const ErrorProperty PARTS_LIBRARY_NAME = const ErrorProperty('PARTS_LIBRARY_NAME', 1); /** * A property whose value is a list of [ExecutableElement] that should * be but are not implemented by a concrete class. */ static const ErrorProperty UNIMPLEMENTED_METHODS = const ErrorProperty('UNIMPLEMENTED_METHODS', 2); static const List<ErrorProperty> values = const [ NOT_INITIALIZED_FIELDS, PARTS_LIBRARY_NAME, UNIMPLEMENTED_METHODS ]; const ErrorProperty(String name, int ordinal) : super(name, ordinal); } /** * An object used to create analysis errors and report then to an error * listener. */ class ErrorReporter { /** * The error listener to which errors will be reported. */ final AnalysisErrorListener _errorListener; /** * The default source to be used when reporting errors. */ final Source _defaultSource; /** * The source to be used when reporting errors. */ Source _source; /** * Initialize a newly created error reporter that will report errors to the * given [_errorListener]. Errors will be reported against the * [_defaultSource] unless another source is provided later. */ ErrorReporter(this._errorListener, this._defaultSource) { if (_errorListener == null) { throw new IllegalArgumentException("An error listener must be provided"); } else if (_defaultSource == null) { throw new IllegalArgumentException("A default source must be provided"); } this._source = _defaultSource; } Source get source => _source; /** * Set the source to be used when reporting errors to the given [source]. * Setting the source to `null` will cause the default source to be used. */ void set source(Source source) { this._source = source == null ? _defaultSource : source; } /** * Creates an error with properties with the given [errorCode] and * [arguments]. The [node] is used to compute the location of the error. */ AnalysisErrorWithProperties newErrorWithProperties( ErrorCode errorCode, AstNode node, List<Object> arguments) => new AnalysisErrorWithProperties.con2( _source, node.offset, node.length, errorCode, arguments); /** * Report the given [error]. */ void reportError(AnalysisError error) { _errorListener.onError(error); } /** * Report an error with the given [errorCode] and [arguments]. The [element] * is used to compute the location of the error. */ void reportErrorForElement( ErrorCode errorCode, Element element, List<Object> arguments) { String displayName = element.displayName; int length = 0; if (displayName != null) { length = displayName.length; } else if (element is ImportElement) { length = 6; // 'import'.length } else if (element is ExportElement) { length = 6; // 'export'.length } reportErrorForOffset(errorCode, element.nameOffset, length, arguments); } /** * Report an error with the given [errorCode] and [arguments]. * The [node] is used to compute the location of the error. * * If the arguments contain the names of two or more types, the method * [reportTypeErrorForNode] should be used and the types * themselves (rather than their names) should be passed as arguments. */ void reportErrorForNode(ErrorCode errorCode, AstNode node, [List<Object> arguments]) { reportErrorForOffset(errorCode, node.offset, node.length, arguments); } /** * Report an error with the given [errorCode] and [arguments]. The location of * the error is specified by the given [offset] and [length]. */ void reportErrorForOffset(ErrorCode errorCode, int offset, int length, [List<Object> arguments]) { _errorListener.onError( new AnalysisError.con2(_source, offset, length, errorCode, arguments)); } /** * Report an error with the given [errorCode] and [arguments]. The [token] is * used to compute the location of the error. */ void reportErrorForToken(ErrorCode errorCode, Token token, [List<Object> arguments]) { reportErrorForOffset(errorCode, token.offset, token.length, arguments); } /** * Report an error with the given [errorCode] and [arguments]. The [node] is * used to compute the location of the error. The arguments are expected to * contain two or more types. Convert the types into strings by using the * display names of the types, unless there are two or more types with the * same names, in which case the extended display names of the types will be * used in order to clarify the message. * * If there are not two or more types in the argument list, the method * [reportErrorForNode] should be used instead. */ void reportTypeErrorForNode( ErrorCode errorCode, AstNode node, List<Object> arguments) { _convertTypeNames(arguments); reportErrorForOffset(errorCode, node.offset, node.length, arguments); } /** * Given an array of [arguments] that is expected to contain two or more * types, convert the types into strings by using the display names of the * types, unless there are two or more types with the same names, in which * case the extended display names of the types will be used in order to * clarify the message. */ void _convertTypeNames(List<Object> arguments) { if (_hasEqualTypeNames(arguments)) { int count = arguments.length; for (int i = 0; i < count; i++) { Object argument = arguments[i]; if (argument is DartType) { DartType type = argument; Element element = type.element; if (element == null) { arguments[i] = type.displayName; } else { arguments[i] = element.getExtendedDisplayName(type.displayName); } } } } else { int count = arguments.length; for (int i = 0; i < count; i++) { Object argument = arguments[i]; if (argument is DartType) { arguments[i] = argument.displayName; } } } } /** * Return `true` if the given array of [arguments] contains two or more types * with the same display name. */ bool _hasEqualTypeNames(List<Object> arguments) { int count = arguments.length; HashSet<String> typeNames = new HashSet<String>(); for (int i = 0; i < count; i++) { if (arguments[i] is DartType && !typeNames.add((arguments[i] as DartType).displayName)) { return true; } } return false; } } /** * The severity of an [ErrorCode]. */ class ErrorSeverity extends Enum<ErrorSeverity> { /** * The severity representing a non-error. This is never used for any error * code, but is useful for clients. */ static const ErrorSeverity NONE = const ErrorSeverity('NONE', 0, " ", "none"); /** * The severity representing an informational level analysis issue. */ static const ErrorSeverity INFO = const ErrorSeverity('INFO', 1, "I", "info"); /** * The severity representing a warning. Warnings can become errors if the `-Werror` command * line flag is specified. */ static const ErrorSeverity WARNING = const ErrorSeverity('WARNING', 2, "W", "warning"); /** * The severity representing an error. */ static const ErrorSeverity ERROR = const ErrorSeverity('ERROR', 3, "E", "error"); static const List<ErrorSeverity> values = const [NONE, INFO, WARNING, ERROR]; /** * The name of the severity used when producing machine output. */ final String machineCode; /** * The name of the severity used when producing readable output. */ final String displayName; /** * Initialize a newly created severity with the given names. * * Parameters: * 0: the name of the severity used when producing machine output * 1: the name of the severity used when producing readable output */ const ErrorSeverity( String name, int ordinal, this.machineCode, this.displayName) : super(name, ordinal); /** * Return the severity constant that represents the greatest severity. */ ErrorSeverity max(ErrorSeverity severity) => this.ordinal >= severity.ordinal ? this : severity; } /** * The type of an [ErrorCode]. */ class ErrorType extends Enum<ErrorType> { /** * Task (todo) comments in user code. */ static const ErrorType TODO = const ErrorType('TODO', 0, ErrorSeverity.INFO); /** * Extra analysis run over the code to follow best practices, which are not in * the Dart Language Specification. */ static const ErrorType HINT = const ErrorType('HINT', 1, ErrorSeverity.INFO); /** * Compile-time errors are errors that preclude execution. A compile time * error must be reported by a Dart compiler before the erroneous code is * executed. */ static const ErrorType COMPILE_TIME_ERROR = const ErrorType('COMPILE_TIME_ERROR', 2, ErrorSeverity.ERROR); /** * Checked mode compile-time errors are errors that preclude execution in * checked mode. */ static const ErrorType CHECKED_MODE_COMPILE_TIME_ERROR = const ErrorType( 'CHECKED_MODE_COMPILE_TIME_ERROR', 3, ErrorSeverity.ERROR); /** * Static warnings are those warnings reported by the static checker. They * have no effect on execution. Static warnings must be provided by Dart * compilers used during development. */ static const ErrorType STATIC_WARNING = const ErrorType('STATIC_WARNING', 4, ErrorSeverity.WARNING); /** * Many, but not all, static warnings relate to types, in which case they are * known as static type warnings. */ static const ErrorType STATIC_TYPE_WARNING = const ErrorType('STATIC_TYPE_WARNING', 5, ErrorSeverity.WARNING); /** * Syntactic errors are errors produced as a result of input that does not * conform to the grammar. */ static const ErrorType SYNTACTIC_ERROR = const ErrorType('SYNTACTIC_ERROR', 6, ErrorSeverity.ERROR); /** * Lint warnings describe style and best practice recommendations that can be * used to formalize a project's style guidelines. */ static const ErrorType LINT = const ErrorType('LINT', 7, ErrorSeverity.INFO); static const List<ErrorType> values = const [ TODO, HINT, COMPILE_TIME_ERROR, CHECKED_MODE_COMPILE_TIME_ERROR, STATIC_WARNING, STATIC_TYPE_WARNING, SYNTACTIC_ERROR, LINT ]; /** * The severity of this type of error. */ final ErrorSeverity severity; /** * Initialize a newly created error type to have the given [name] and * [severity]. */ const ErrorType(String name, int ordinal, this.severity) : super(name, ordinal); String get displayName => name.toLowerCase().replaceAll('_', ' '); } /** * The hints and coding recommendations for best practices which are not * mentioned in the Dart Language Specification. */ class HintCode extends ErrorCode { /** * This hint is generated anywhere where the * [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE] would have been generated, * if we used propagated information for the warnings. * * Parameters: * 0: the name of the actual argument type * 1: the name of the expected type */ static const HintCode ARGUMENT_TYPE_NOT_ASSIGNABLE = const HintCode( 'ARGUMENT_TYPE_NOT_ASSIGNABLE', "The argument type '{0}' cannot be assigned to the parameter type '{1}'"); /** * Dead code is code that is never reached, this can happen for instance if a * statement follows a return statement. */ static const HintCode DEAD_CODE = const HintCode('DEAD_CODE', "Dead code"); /** * Dead code is code that is never reached. This case covers cases where the * user has catch clauses after `catch (e)` or `on Object catch (e)`. */ static const HintCode DEAD_CODE_CATCH_FOLLOWING_CATCH = const HintCode( 'DEAD_CODE_CATCH_FOLLOWING_CATCH', "Dead code, catch clauses after a 'catch (e)' or an 'on Object catch (e)' are never reached"); /** * Dead code is code that is never reached. This case covers cases where the * user has an on-catch clause such as `on A catch (e)`, where a supertype of * `A` was already caught. * * Parameters: * 0: name of the subtype * 1: name of the supertype */ static const HintCode DEAD_CODE_ON_CATCH_SUBTYPE = const HintCode( 'DEAD_CODE_ON_CATCH_SUBTYPE', "Dead code, this on-catch block will never be executed since '{0}' is a subtype of '{1}'"); /** * Deprecated members should not be invoked or used. * * Parameters: * 0: the name of the member */ static const HintCode DEPRECATED_MEMBER_USE = const HintCode('DEPRECATED_MEMBER_USE', "'{0}' is deprecated"); /** * Duplicate imports. */ static const HintCode DUPLICATE_IMPORT = const HintCode('DUPLICATE_IMPORT', "Duplicate import"); /** * Hint to use the ~/ operator. */ static const HintCode DIVISION_OPTIMIZATION = const HintCode( 'DIVISION_OPTIMIZATION', "The operator x ~/ y is more efficient than (x / y).toInt()"); /** * Hint for the `x is double` type checks. */ static const HintCode IS_DOUBLE = const HintCode('IS_DOUBLE', "When compiled to JS, this test might return true when the left hand side is an int"); /** * Hint for the `x is int` type checks. */ static const HintCode IS_INT = const HintCode('IS_INT', "When compiled to JS, this test might return true when the left hand side is a double"); /** * Hint for the `x is! double` type checks. */ static const HintCode IS_NOT_DOUBLE = const HintCode('IS_NOT_DOUBLE', "When compiled to JS, this test might return false when the left hand side is an int"); /** * Hint for the `x is! int` type checks. */ static const HintCode IS_NOT_INT = const HintCode('IS_NOT_INT', "When compiled to JS, this test might return false when the left hand side is a double"); /** * Deferred libraries shouldn't define a top level function 'loadLibrary'. */ static const HintCode IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION = const HintCode( 'IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION', "The library '{0}' defines a top-level function named 'loadLibrary' which is hidden by deferring this library"); /** * This hint is generated anywhere where the * [StaticTypeWarningCode.INVALID_ASSIGNMENT] would have been generated, if we * used propagated information for the warnings. * * Parameters: * 0: the name of the right hand side type * 1: the name of the left hand side type */ static const HintCode INVALID_ASSIGNMENT = const HintCode( 'INVALID_ASSIGNMENT', "A value of type '{0}' cannot be assigned to a variable of type '{1}'"); /** * Generate a hint for methods or functions that have a return type, but do * not have a non-void return statement on all branches. At the end of methods * or functions with no return, Dart implicitly returns `null`, avoiding these * implicit returns is considered a best practice. * * Parameters: * 0: the name of the declared return type */ static const HintCode MISSING_RETURN = const HintCode('MISSING_RETURN', "This function declares a return type of '{0}', but does not end with a return statement", "Either add a return statement or change the return type to 'void'"); /** * A getter with the override annotation does not override an existing getter. */ static const HintCode OVERRIDE_ON_NON_OVERRIDING_GETTER = const HintCode( 'OVERRIDE_ON_NON_OVERRIDING_GETTER', "Getter does not override an inherited getter"); /** * A method with the override annotation does not override an existing method. */ static const HintCode OVERRIDE_ON_NON_OVERRIDING_METHOD = const HintCode( 'OVERRIDE_ON_NON_OVERRIDING_METHOD', "Method does not override an inherited method"); /** * A setter with the override annotation does not override an existing setter. */ static const HintCode OVERRIDE_ON_NON_OVERRIDING_SETTER = const HintCode( 'OVERRIDE_ON_NON_OVERRIDING_SETTER', "Setter does not override an inherited setter"); /** * Hint for classes that override equals, but not hashCode. * * Parameters: * 0: the name of the current class */ static const HintCode OVERRIDE_EQUALS_BUT_NOT_HASH_CODE = const HintCode( 'OVERRIDE_EQUALS_BUT_NOT_HASH_CODE', "The class '{0}' overrides 'operator==', but not 'get hashCode'"); /** * Type checks of the type `x is! Null` should be done with `x != null`. */ static const HintCode TYPE_CHECK_IS_NOT_NULL = const HintCode( 'TYPE_CHECK_IS_NOT_NULL', "Tests for non-null should be done with '!= null'"); /** * Type checks of the type `x is Null` should be done with `x == null`. */ static const HintCode TYPE_CHECK_IS_NULL = const HintCode( 'TYPE_CHECK_IS_NULL', "Tests for null should be done with '== null'"); /** * This hint is generated anywhere where the * [StaticTypeWarningCode.UNDEFINED_GETTER] or * [StaticWarningCode.UNDEFINED_GETTER] would have been generated, if we used * propagated information for the warnings. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the getter is being looked for */ static const HintCode UNDEFINED_GETTER = const HintCode('UNDEFINED_GETTER', "The getter '{0}' is not defined for the class '{1}'"); /** * This hint is generated anywhere where the * [StaticTypeWarningCode.UNDEFINED_METHOD] would have been generated, if we * used propagated information for the warnings. * * Parameters: * 0: the name of the method that is undefined * 1: the resolved type name that the method lookup is happening on */ static const HintCode UNDEFINED_METHOD = const HintCode('UNDEFINED_METHOD', "The method '{0}' is not defined for the class '{1}'"); /** * This hint is generated anywhere where the * [StaticTypeWarningCode.UNDEFINED_OPERATOR] would have been generated, if we * used propagated information for the warnings. * * Parameters: * 0: the name of the operator * 1: the name of the enclosing type where the operator is being looked for */ static const HintCode UNDEFINED_OPERATOR = const HintCode( 'UNDEFINED_OPERATOR', "The operator '{0}' is not defined for the class '{1}'"); /** * This hint is generated anywhere where the * [StaticTypeWarningCode.UNDEFINED_SETTER] or * [StaticWarningCode.UNDEFINED_SETTER] would have been generated, if we used * propagated information for the warnings. * * Parameters: * 0: the name of the setter * 1: the name of the enclosing type where the setter is being looked for */ static const HintCode UNDEFINED_SETTER = const HintCode('UNDEFINED_SETTER', "The setter '{0}' is not defined for the class '{1}'"); /** * Unnecessary cast. */ static const HintCode UNNECESSARY_CAST = const HintCode('UNNECESSARY_CAST', "Unnecessary cast"); /** * Unnecessary type checks, the result is always true. */ static const HintCode UNNECESSARY_TYPE_CHECK_FALSE = const HintCode( 'UNNECESSARY_TYPE_CHECK_FALSE', "Unnecessary type check, the result is always false"); /** * Unnecessary type checks, the result is always false. */ static const HintCode UNNECESSARY_TYPE_CHECK_TRUE = const HintCode( 'UNNECESSARY_TYPE_CHECK_TRUE', "Unnecessary type check, the result is always true"); /** * See [Modifier.IS_USED_IN_LIBRARY]. */ static const HintCode UNUSED_ELEMENT = const HintCode('UNUSED_ELEMENT', "The {0} '{1}' is not used"); /** * Unused fields are fields which are never read. */ static const HintCode UNUSED_FIELD = const HintCode( 'UNUSED_FIELD', "The value of the field '{0}' is not used"); /** * Unused imports are imports which are never used. */ static const HintCode UNUSED_IMPORT = const HintCode('UNUSED_IMPORT', "Unused import"); /** * Unused catch exception variables. */ static const HintCode UNUSED_CATCH_CLAUSE = const HintCode( 'UNUSED_CATCH_CLAUSE', "The exception variable '{0}' is not used, so the 'catch' clause can be removed"); /** * Unused catch stack trace variables. */ static const HintCode UNUSED_CATCH_STACK = const HintCode( 'UNUSED_CATCH_STACK', "The stack trace variable '{0}' is not used and can be removed"); /** * Unused local variables are local varaibles which are never read. */ static const HintCode UNUSED_LOCAL_VARIABLE = const HintCode( 'UNUSED_LOCAL_VARIABLE', "The value of the local variable '{0}' is not used"); /** * Hint for cases where the source expects a method or function to return a * non-void result, but the method or function signature returns void. * * Parameters: * 0: the name of the method or function that returns void */ static const HintCode USE_OF_VOID_RESULT = const HintCode( 'USE_OF_VOID_RESULT', "The result of '{0}' is being used, even though it is declared to be 'void'"); /** * It is a bad practice for a source file in a package "lib" directory * hierarchy to traverse outside that directory hierarchy. For example, a * source file in the "lib" directory should not contain a directive such as * `import '../web/some.dart'` which references a file outside the lib * directory. */ static const HintCode FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE = const HintCode('FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE', "A file in the 'lib' directory hierarchy should not reference a file outside that hierarchy"); /** * It is a bad practice for a source file ouside a package "lib" directory * hierarchy to traverse into that directory hierarchy. For example, a source * file in the "web" directory should not contain a directive such as * `import '../lib/some.dart'` which references a file inside the lib * directory. */ static const HintCode FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE = const HintCode('FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE', "A file outside the 'lib' directory hierarchy should not reference a file inside that hierarchy. Use a package: reference instead."); /** * It is a bad practice for a package import to reference anything outside the * given package, or more generally, it is bad practice for a package import * to contain a "..". For example, a source file should not contain a * directive such as `import 'package:foo/../some.dart'`. */ static const HintCode PACKAGE_IMPORT_CONTAINS_DOT_DOT = const HintCode( 'PACKAGE_IMPORT_CONTAINS_DOT_DOT', "A package import should not contain '..'"); /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const HintCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorType.HINT.severity; @override ErrorType get type => ErrorType.HINT; } /** * The error codes used for warnings in HTML files. The convention for this * class is for the name of the error code to indicate the problem that caused * the error to be generated and for the error message to explain what is wrong * and, when appropriate, how the problem can be corrected. */ class HtmlWarningCode extends ErrorCode { /** * An error code indicating that the value of the 'src' attribute of a Dart * script tag is not a valid URI. * * Parameters: * 0: the URI that is invalid */ static const HtmlWarningCode INVALID_URI = const HtmlWarningCode('INVALID_URI', "Invalid URI syntax: '{0}'"); /** * An error code indicating that the value of the 'src' attribute of a Dart * script tag references a file that does not exist. * * Parameters: * 0: the URI pointing to a non-existent file */ static const HtmlWarningCode URI_DOES_NOT_EXIST = const HtmlWarningCode( 'URI_DOES_NOT_EXIST', "Target of URI does not exist: '{0}'"); /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const HtmlWarningCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorSeverity.WARNING; @override ErrorType get type => ErrorType.STATIC_WARNING; } /** * Defines style and best practice recommendations. * * Unlike [HintCode]s, which are akin to traditional static warnings from a * compiler, lint recommendations focus on matters of style and practices that * might aggregated to define a project's style guide. */ class LintCode extends ErrorCode { const LintCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorSeverity.INFO; @override ErrorType get type => ErrorType.LINT; } /** * The error codes used for static type warnings. The convention for this class * is for the name of the error code to indicate the problem that caused the * error to be generated and for the error message to explain what is wrong and, * when appropriate, how the problem can be corrected. */ class StaticTypeWarningCode extends ErrorCode { /** * 12.7 Lists: A fresh instance (7.6.1) a, of size n, whose * class implements the built-in class List<E> is allocated. * * Parameters: * 0: the number of provided type arguments */ static const StaticTypeWarningCode EXPECTED_ONE_LIST_TYPE_ARGUMENTS = const StaticTypeWarningCode('EXPECTED_ONE_LIST_TYPE_ARGUMENTS', "List literal requires exactly one type arguments or none, but {0} found"); /** * 12.8 Maps: A fresh instance (7.6.1) m, of size n, whose class * implements the built-in class Map<K, V> is allocated. * * Parameters: * 0: the number of provided type arguments */ static const StaticTypeWarningCode EXPECTED_TWO_MAP_TYPE_ARGUMENTS = const StaticTypeWarningCode('EXPECTED_TWO_MAP_TYPE_ARGUMENTS', "Map literal requires exactly two type arguments or none, but {0} found"); /** * 9 Functions: It is a static warning if the declared return type of a * function marked async* may not be assigned to Stream. */ static const StaticTypeWarningCode ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE = const StaticTypeWarningCode('ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE', "Functions marked 'async*' must have a return type assignable to 'Stream'"); /** * 9 Functions: It is a static warning if the declared return type of a * function marked async may not be assigned to Future. */ static const StaticTypeWarningCode ILLEGAL_ASYNC_RETURN_TYPE = const StaticTypeWarningCode('ILLEGAL_ASYNC_RETURN_TYPE', "Functions marked 'async' must have a return type assignable to 'Future'"); /** * 9 Functions: It is a static warning if the declared return type of a * function marked sync* may not be assigned to Iterable. */ static const StaticTypeWarningCode ILLEGAL_SYNC_GENERATOR_RETURN_TYPE = const StaticTypeWarningCode('ILLEGAL_SYNC_GENERATOR_RETURN_TYPE', "Functions marked 'sync*' must have a return type assignable to 'Iterable'"); /** * 12.18 Assignment: Let T be the static type of e1. * It is a static type warning if T does not have an accessible * instance setter named v=. * * See [UNDEFINED_SETTER]. */ static const StaticTypeWarningCode INACCESSIBLE_SETTER = const StaticTypeWarningCode('INACCESSIBLE_SETTER', ""); /** * 8.1.1 Inheritance and Overriding: However, if the above rules would cause * multiple members m1, …, mk with the * same name n that would be inherited (because identically named * members existed in several superinterfaces) then at most one member is * inherited. * * If the static types T1, …, Tk of the * members m1, …, mk are not identical, * then there must be a member mx such that Tx * <: Ti, 1 <= x <= k for all i, 1 <= i <= * k, or a static type warning occurs. The member that is inherited is * mx, if it exists; otherwise: * * Let numberOfPositionals(f) denote the number of positional * parameters of a function f, and let * numberOfRequiredParams(f) denote the number of required * parameters of a function f. Furthermore, let s denote the * set of all named parameters of the m1, …, * mk. Then let * * h = max(numberOfPositionals(mi)), * * r = min(numberOfRequiredParams(mi)), for all i, 1 <= * i <= k. If r <= h then I has a method named n, * with r required parameters of type dynamic, h * positional parameters of type dynamic, named parameters s * of type dynamic and return type dynamic. * * Otherwise none of the members m1, …, * mk is inherited. */ static const StaticTypeWarningCode INCONSISTENT_METHOD_INHERITANCE = const StaticTypeWarningCode('INCONSISTENT_METHOD_INHERITANCE', "'{0}' is inherited by at least two interfaces inconsistently, from {1}"); /** * 12.15.1 Ordinary Invocation: It is a static type warning if T does * not have an accessible (3.2) instance member named m. * * Parameters: * 0: the name of the static member * * See [UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]. */ static const StaticTypeWarningCode INSTANCE_ACCESS_TO_STATIC_MEMBER = const StaticTypeWarningCode('INSTANCE_ACCESS_TO_STATIC_MEMBER', "Static member '{0}' cannot be accessed using instance access"); /** * 12.18 Assignment: It is a static type warning if the static type of * e may not be assigned to the static type of v. The static * type of the expression v = e is the static type of e. * * 12.18 Assignment: It is a static type warning if the static type of * e may not be assigned to the static type of C.v. The static * type of the expression C.v = e is the static type of e. * * 12.18 Assignment: Let T be the static type of e1. * It is a static type warning if the static type of e2 may * not be assigned to T. * * Parameters: * 0: the name of the right hand side type * 1: the name of the left hand side type */ static const StaticTypeWarningCode INVALID_ASSIGNMENT = const StaticTypeWarningCode('INVALID_ASSIGNMENT', "A value of type '{0}' cannot be assigned to a variable of type '{1}'"); /** * 12.15.1 Ordinary Invocation: An ordinary method invocation i has the * form o.m(a1, …, an, xn+1: * an+1, … xn+k: an+k). * * Let T be the static type of o. It is a static type warning if * T does not have an accessible instance member named m. If * T.m exists, it is a static warning if the type F of * T.m may not be assigned to a function type. If T.m does not * exist, or if F is not a function type, the static type of i * is dynamic. * * 12.15.3 Static Invocation: It is a static type warning if the type F * of C.m may not be assigned to a function type. * * 12.15.4 Super Invocation: A super method invocation i has the form * super.m(a1, …, an, xn+1: * an+1, … xn+k: an+k). If * S.m exists, it is a static warning if the type F of * S.m may not be assigned to a function type. * * Parameters: * 0: the name of the identifier that is not a function type */ static const StaticTypeWarningCode INVOCATION_OF_NON_FUNCTION = const StaticTypeWarningCode( 'INVOCATION_OF_NON_FUNCTION', "'{0}' is not a method"); /** * 12.14.4 Function Expression Invocation: A function expression invocation * i has the form ef(a1, …, * an, xn+1: an+1, …, xn+k: * an+k), where ef is an expression. * * It is a static type warning if the static type F of * ef may not be assigned to a function type. */ static const StaticTypeWarningCode INVOCATION_OF_NON_FUNCTION_EXPRESSION = const StaticTypeWarningCode('INVOCATION_OF_NON_FUNCTION_EXPRESSION', "Cannot invoke a non-function"); /** * 12.20 Conditional: It is a static type warning if the type of * e1 may not be assigned to bool. * * 13.5 If: It is a static type warning if the type of the expression b * may not be assigned to bool. * * 13.7 While: It is a static type warning if the type of e may not be * assigned to bool. * * 13.8 Do: It is a static type warning if the type of e cannot be * assigned to bool. */ static const StaticTypeWarningCode NON_BOOL_CONDITION = const StaticTypeWarningCode( 'NON_BOOL_CONDITION', "Conditions must have a static type of 'bool'"); /** * 13.15 Assert: It is a static type warning if the type of e may not * be assigned to either bool or () → bool */ static const StaticTypeWarningCode NON_BOOL_EXPRESSION = const StaticTypeWarningCode('NON_BOOL_EXPRESSION', "Assertions must be on either a 'bool' or '() -> bool'"); /** * 12.28 Unary Expressions: The expression !e is equivalent to the * expression e?false : true. * * 12.20 Conditional: It is a static type warning if the type of * e1 may not be assigned to bool. */ static const StaticTypeWarningCode NON_BOOL_NEGATION_EXPRESSION = const StaticTypeWarningCode('NON_BOOL_NEGATION_EXPRESSION', "Negation argument must have a static type of 'bool'"); /** * 12.21 Logical Boolean Expressions: It is a static type warning if the * static types of both of e1 and e2 may * not be assigned to bool. * * Parameters: * 0: the lexeme of the logical operator */ static const StaticTypeWarningCode NON_BOOL_OPERAND = const StaticTypeWarningCode('NON_BOOL_OPERAND', "The operands of the '{0}' operator must be assignable to 'bool'"); /** * 15.8 Parameterized Types: It is a static type warning if Ai, * 1 <= i <= n does not denote a type in the enclosing lexical scope. */ static const StaticTypeWarningCode NON_TYPE_AS_TYPE_ARGUMENT = const StaticTypeWarningCode('NON_TYPE_AS_TYPE_ARGUMENT', "The name '{0}' is not a type and cannot be used as a parameterized type"); /** * 13.11 Return: It is a static type warning if the type of e may not * be assigned to the declared return type of the immediately enclosing * function. * * Parameters: * 0: the return type as declared in the return statement * 1: the expected return type as defined by the method * 2: the name of the method */ static const StaticTypeWarningCode RETURN_OF_INVALID_TYPE = const StaticTypeWarningCode('RETURN_OF_INVALID_TYPE', "The return type '{0}' is not a '{1}', as defined by the method '{2}'"); /** * 12.11 Instance Creation: It is a static type warning if any of the type * arguments to a constructor of a generic type G invoked by a new * expression or a constant object expression are not subtypes of the bounds * of the corresponding formal type parameters of G. * * 15.8 Parameterized Types: If S is the static type of a member * m of G, then the static type of the member m of * G<A1, …, An> is [A1, * …, An/T1, …, Tn]S where * T1, …, Tn are the formal type * parameters of G. Let Bi be the bounds of * Ti, 1 <= i <= n. It is a static type warning if * Ai is not a subtype of [A1, …, * An/T1, …, Tn]Bi, 1 <= * i <= n. * * 7.6.2 Factories: It is a static type warning if any of the type arguments * to k' are not subtypes of the bounds of the corresponding formal * type parameters of type. * * Parameters: * 0: the name of the type used in the instance creation that should be * limited by the bound as specified in the class declaration * 1: the name of the bounding type * * See [TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND]. */ static const StaticTypeWarningCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS = const StaticTypeWarningCode( 'TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', "'{0}' does not extend '{1}'"); /** * 10 Generics: It is a static type warning if a type parameter is a supertype * of its upper bound. * * Parameters: * 0: the name of the type parameter * * See [TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]. */ static const StaticTypeWarningCode TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND = const StaticTypeWarningCode('TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND', "'{0}' cannot be a supertype of its upper bound"); /** * 12.17 Getter Invocation: It is a static warning if there is no class * C in the enclosing lexical scope of i, or if C does * not declare, implicitly or explicitly, a getter named m. * * Parameters: * 0: the name of the enumeration constant that is not defined * 1: the name of the enumeration used to access the constant */ static const StaticTypeWarningCode UNDEFINED_ENUM_CONSTANT = const StaticTypeWarningCode('UNDEFINED_ENUM_CONSTANT', "There is no constant named '{0}' in '{1}'"); /** * 12.15.3 Unqualified Invocation: If there exists a lexically visible * declaration named id, let fid be the innermost * such declaration. Then: [skip]. Otherwise, fid is * considered equivalent to the ordinary method invocation * this.id(a1, ..., an, * xn+1 : an+1, ..., * xn+k : an+k). * * Parameters: * 0: the name of the method that is undefined */ static const StaticTypeWarningCode UNDEFINED_FUNCTION = const StaticTypeWarningCode( 'UNDEFINED_FUNCTION', "The function '{0}' is not defined"); /** * 12.17 Getter Invocation: Let T be the static type of e. It is * a static type warning if T does not have a getter named m. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the getter is being looked for */ static const StaticTypeWarningCode UNDEFINED_GETTER = const StaticTypeWarningCode('UNDEFINED_GETTER', "The getter '{0}' is not defined for the class '{1}'"); /** * 12.15.1 Ordinary Invocation: Let T be the static type of o. * It is a static type warning if T does not have an accessible * instance member named m. * * Parameters: * 0: the name of the method that is undefined * 1: the resolved type name that the method lookup is happening on */ static const StaticTypeWarningCode UNDEFINED_METHOD = const StaticTypeWarningCode('UNDEFINED_METHOD', "The method '{0}' is not defined for the class '{1}'"); /** * 12.18 Assignment: Evaluation of an assignment of the form * e1[e2] = e3 is * equivalent to the evaluation of the expression (a, i, e){a.[]=(i, e); * return e;} (e1, e2, * e2). * * 12.29 Assignable Expressions: An assignable expression of the form * e1[e2] is evaluated as a method * invocation of the operator method [] on e1 with argument * e2. * * 12.15.1 Ordinary Invocation: Let T be the static type of o. * It is a static type warning if T does not have an accessible * instance member named m. * * Parameters: * 0: the name of the operator * 1: the name of the enclosing type where the operator is being looked for */ static const StaticTypeWarningCode UNDEFINED_OPERATOR = const StaticTypeWarningCode('UNDEFINED_OPERATOR', "The operator '{0}' is not defined for the class '{1}'"); /** * 12.18 Assignment: Let T be the static type of e1. * It is a static type warning if T does not have an accessible * instance setter named v=. * * Parameters: * 0: the name of the setter * 1: the name of the enclosing type where the setter is being looked for * * See [INACCESSIBLE_SETTER]. */ static const StaticTypeWarningCode UNDEFINED_SETTER = const StaticTypeWarningCode('UNDEFINED_SETTER', "The setter '{0}' is not defined for the class '{1}'"); /** * 12.17 Getter Invocation: Let T be the static type of e. It is * a static type warning if T does not have a getter named m. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the getter is being looked for */ static const StaticTypeWarningCode UNDEFINED_SUPER_GETTER = const StaticTypeWarningCode('UNDEFINED_SUPER_GETTER', "The getter '{0}' is not defined in a superclass of '{1}'"); /** * 12.15.4 Super Invocation: A super method invocation i has the form * super.m(a1, …, an, xn+1: * an+1, … xn+k: an+k). It is a * static type warning if S does not have an accessible instance member * named m. * * Parameters: * 0: the name of the method that is undefined * 1: the resolved type name that the method lookup is happening on */ static const StaticTypeWarningCode UNDEFINED_SUPER_METHOD = const StaticTypeWarningCode('UNDEFINED_SUPER_METHOD', "The method '{0}' is not defined in a superclass of '{1}'"); /** * 12.18 Assignment: Evaluation of an assignment of the form * e1[e2] = e3 is * equivalent to the evaluation of the expression (a, i, e){a.[]=(i, e); * return e;} (e1, e2, * e2). * * 12.29 Assignable Expressions: An assignable expression of the form * e1[e2] is evaluated as a method * invocation of the operator method [] on e1 with argument * e2. * * 12.15.1 Ordinary Invocation: Let T be the static type of o. * It is a static type warning if T does not have an accessible * instance member named m. * * Parameters: * 0: the name of the operator * 1: the name of the enclosing type where the operator is being looked for */ static const StaticTypeWarningCode UNDEFINED_SUPER_OPERATOR = const StaticTypeWarningCode('UNDEFINED_SUPER_OPERATOR', "The operator '{0}' is not defined in a superclass of '{1}'"); /** * 12.18 Assignment: Let T be the static type of e1. * It is a static type warning if T does not have an accessible * instance setter named v=. * * Parameters: * 0: the name of the setter * 1: the name of the enclosing type where the setter is being looked for * * See [INACCESSIBLE_SETTER]. */ static const StaticTypeWarningCode UNDEFINED_SUPER_SETTER = const StaticTypeWarningCode('UNDEFINED_SUPER_SETTER', "The setter '{0}' is not defined in a superclass of '{1}'"); /** * 12.15.1 Ordinary Invocation: It is a static type warning if T does * not have an accessible (3.2) instance member named m. * * This is a specialization of [INSTANCE_ACCESS_TO_STATIC_MEMBER] that is used * when we are able to find the name defined in a supertype. It exists to * provide a more informative error message. */ static const StaticTypeWarningCode UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER = const StaticTypeWarningCode( 'UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER', "Static members from supertypes must be qualified by the name of the defining type"); /** * 15.8 Parameterized Types: It is a static type warning if G is not a * generic type with exactly n type parameters. * * Parameters: * 0: the name of the type being referenced (G) * 1: the number of type parameters that were declared * 2: the number of type arguments provided * * See [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS], and * [CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]. */ static const StaticTypeWarningCode WRONG_NUMBER_OF_TYPE_ARGUMENTS = const StaticTypeWarningCode('WRONG_NUMBER_OF_TYPE_ARGUMENTS', "The type '{0}' is declared with {1} type parameters, but {2} type arguments were given"); /** * 17.16.1 Yield: Let T be the static type of e [the expression to the right * of "yield"] and let f be the immediately enclosing function. It is a * static type warning if either: * * - the body of f is marked async* and the type Stream<T> may not be * assigned to the declared return type of f. * * - the body of f is marked sync* and the type Iterable<T> may not be * assigned to the declared return type of f. * * 17.16.2 Yield-Each: Let T be the static type of e [the expression to the * right of "yield*"] and let f be the immediately enclosing function. It is * a static type warning if T may not be assigned to the declared return type * of f. If f is synchronous it is a static type warning if T may not be * assigned to Iterable. If f is asynchronous it is a static type warning if * T may not be assigned to Stream. */ static const StaticTypeWarningCode YIELD_OF_INVALID_TYPE = const StaticTypeWarningCode('YIELD_OF_INVALID_TYPE', "The type '{0}' implied by the 'yield' expression must be assignable to '{1}'"); /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const StaticTypeWarningCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorType.STATIC_TYPE_WARNING.severity; @override ErrorType get type => ErrorType.STATIC_TYPE_WARNING; } /** * The error codes used for static warnings. The convention for this class is * for the name of the error code to indicate the problem that caused the error * to be generated and for the error message to explain what is wrong and, when * appropriate, how the problem can be corrected. */ class StaticWarningCode extends ErrorCode { /** * 14.1 Imports: If a name N is referenced by a library L and * N is introduced into the top level scope L by more than one * import then: * 1. A static warning occurs. * 2. If N is referenced as a function, getter or setter, a * NoSuchMethodError is raised. * 3. If N is referenced as a type, it is treated as a malformed type. * * Parameters: * 0: the name of the ambiguous type * 1: the name of the first library that the type is found * 2: the name of the second library that the type is found */ static const StaticWarningCode AMBIGUOUS_IMPORT = const StaticWarningCode( 'AMBIGUOUS_IMPORT', "The name '{0}' is defined in the libraries {1}", "Consider using 'as prefix' for one of the import directives " "or hiding the name from all but one of the imports."); /** * 12.11.1 New: It is a static warning if the static type of ai, * 1 <= i <= n+ k may not be assigned to the type of the * corresponding formal parameter of the constructor T.id (respectively * T). * * 12.11.2 Const: It is a static warning if the static type of * ai, 1 <= i <= n+ k may not be assigned to the type * of the corresponding formal parameter of the constructor T.id * (respectively T). * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. * * 12.14.2 Binding Actuals to Formals: Furthermore, each qi, 1 * <= i <= l, must have a corresponding named parameter in the set * {pn+1, … pn+k} or a static warning * occurs. It is a static warning if Tm+j may not be * assigned to Sr, where r = qj, 1 <= j * <= l. * * Parameters: * 0: the name of the actual argument type * 1: the name of the expected type */ static const StaticWarningCode ARGUMENT_TYPE_NOT_ASSIGNABLE = const StaticWarningCode('ARGUMENT_TYPE_NOT_ASSIGNABLE', "The argument type '{0}' cannot be assigned to the parameter type '{1}'"); /** * 5 Variables: Attempting to assign to a final variable elsewhere will cause * a NoSuchMethodError to be thrown, because no setter is defined for it. The * assignment will also give rise to a static warning for the same reason. * * A constant variable is always implicitly final. */ static const StaticWarningCode ASSIGNMENT_TO_CONST = const StaticWarningCode( 'ASSIGNMENT_TO_CONST', "Constant variables cannot be assigned a value"); /** * 5 Variables: Attempting to assign to a final variable elsewhere will cause * a NoSuchMethodError to be thrown, because no setter is defined for it. The * assignment will also give rise to a static warning for the same reason. */ static const StaticWarningCode ASSIGNMENT_TO_FINAL = const StaticWarningCode( 'ASSIGNMENT_TO_FINAL', "'{0}' cannot be used as a setter, it is final"); /** * 5 Variables: Attempting to assign to a final variable elsewhere will cause * a NoSuchMethodError to be thrown, because no setter is defined for it. The * assignment will also give rise to a static warning for the same reason. */ static const StaticWarningCode ASSIGNMENT_TO_FINAL_NO_SETTER = const StaticWarningCode('ASSIGNMENT_TO_FINAL_NO_SETTER', "No setter named '{0}' in class '{1}'"); /** * 12.18 Assignment: It is as static warning if an assignment of the form * v = e occurs inside a top level or static function (be it function, * method, getter, or setter) or variable initializer and there is neither a * local variable declaration with name v nor setter declaration with * name v= in the lexical scope enclosing the assignment. */ static const StaticWarningCode ASSIGNMENT_TO_FUNCTION = const StaticWarningCode( 'ASSIGNMENT_TO_FUNCTION', "Functions cannot be assigned a value"); /** * 12.18 Assignment: Let T be the static type of e1 * It is a static type warning if T does not have an accessible * instance setter named v=. */ static const StaticWarningCode ASSIGNMENT_TO_METHOD = const StaticWarningCode( 'ASSIGNMENT_TO_METHOD', "Methods cannot be assigned a value"); /** * 12.18 Assignment: It is as static warning if an assignment of the form * v = e occurs inside a top level or static function (be it function, * method, getter, or setter) or variable initializer and there is neither a * local variable declaration with name v nor setter declaration with * name v= in the lexical scope enclosing the assignment. */ static const StaticWarningCode ASSIGNMENT_TO_TYPE = const StaticWarningCode( 'ASSIGNMENT_TO_TYPE', "Types cannot be assigned a value"); /** * 13.9 Switch: It is a static warning if the last statement of the statement * sequence sk is not a break, continue, return or throw * statement. */ static const StaticWarningCode CASE_BLOCK_NOT_TERMINATED = const StaticWarningCode('CASE_BLOCK_NOT_TERMINATED', "The last statement of the 'case' should be 'break', 'continue', 'return' or 'throw'"); /** * 12.32 Type Cast: It is a static warning if T does not denote a type * available in the current lexical scope. */ static const StaticWarningCode CAST_TO_NON_TYPE = const StaticWarningCode( 'CAST_TO_NON_TYPE', "The name '{0}' is not a type and cannot be used in an 'as' expression"); /** * 7.4 Abstract Instance Members: It is a static warning if an abstract member * is declared or inherited in a concrete class. */ static const StaticWarningCode CONCRETE_CLASS_WITH_ABSTRACT_MEMBER = const StaticWarningCode('CONCRETE_CLASS_WITH_ABSTRACT_MEMBER', "'{0}' must have a method body because '{1}' is not abstract"); /** * 14.1 Imports: If a name N is referenced by a library L and * N would be introduced into the top level scope of L by an * import from a library whose URI begins with dart: and an import from * a library whose URI does not begin with dart:: * * The import from dart: is implicitly extended by a hide N clause. * * A static warning is issued. * * Parameters: * 0: the ambiguous name * 1: the name of the dart: library in which the element is found * 1: the name of the non-dart: library in which the element is found */ static const StaticWarningCode CONFLICTING_DART_IMPORT = const StaticWarningCode('CONFLICTING_DART_IMPORT', "Element '{0}' from SDK library '{1}' is implicitly hidden by '{2}'"); /** * 7.2 Getters: It is a static warning if a class C declares an * instance getter named v and an accessible static member named * v or v= is declared in a superclass of C. * * Parameters: * 0: the name of the super class declaring a static member */ static const StaticWarningCode CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER = const StaticWarningCode( 'CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER', "Superclass '{0}' declares static member with the same name"); /** * 7.1 Instance Methods: It is a static warning if a class C declares * an instance method named n and has a setter named n=. */ static const StaticWarningCode CONFLICTING_INSTANCE_METHOD_SETTER = const StaticWarningCode('CONFLICTING_INSTANCE_METHOD_SETTER', "Class '{0}' declares instance method '{1}', but also has a setter with the same name from '{2}'"); /** * 7.1 Instance Methods: It is a static warning if a class C declares * an instance method named n and has a setter named n=. */ static const StaticWarningCode CONFLICTING_INSTANCE_METHOD_SETTER2 = const StaticWarningCode('CONFLICTING_INSTANCE_METHOD_SETTER2', "Class '{0}' declares the setter '{1}', but also has an instance method in the same class"); /** * 7.3 Setters: It is a static warning if a class C declares an * instance setter named v= and an accessible static member named * v= or v is declared in a superclass of C. * * Parameters: * 0: the name of the super class declaring a static member */ static const StaticWarningCode CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER = const StaticWarningCode( 'CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER', "Superclass '{0}' declares static member with the same name"); /** * 7.2 Getters: It is a static warning if a class declares a static getter * named v and also has a non-static setter named v=. */ static const StaticWarningCode CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER = const StaticWarningCode('CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER', "Class '{0}' declares non-static setter with the same name"); /** * 7.3 Setters: It is a static warning if a class declares a static setter * named v= and also has a non-static member named v. */ static const StaticWarningCode CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER = const StaticWarningCode('CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER', "Class '{0}' declares non-static member with the same name"); /** * 12.11.2 Const: Given an instance creation expression of the form const * q(a1, … an) it is a static warning if * q is the constructor of an abstract class but q is not a * factory constructor. */ static const StaticWarningCode CONST_WITH_ABSTRACT_CLASS = const StaticWarningCode('CONST_WITH_ABSTRACT_CLASS', "Abstract classes cannot be created with a 'const' expression"); /** * 12.7 Maps: It is a static warning if the values of any two keys in a map * literal are equal. */ static const StaticWarningCode EQUAL_KEYS_IN_MAP = const StaticWarningCode( 'EQUAL_KEYS_IN_MAP', "Keys in a map cannot be equal"); /** * 14.2 Exports: It is a static warning to export two different libraries with * the same name. * * Parameters: * 0: the uri pointing to a first library * 1: the uri pointing to a second library * 2:e the shared name of the exported libraries */ static const StaticWarningCode EXPORT_DUPLICATED_LIBRARY_NAMED = const StaticWarningCode('EXPORT_DUPLICATED_LIBRARY_NAMED', "The exported libraries '{0}' and '{1}' cannot have the same name '{2}'"); /** * 14.2 Exports: It is a static warning to export two different libraries with * the same name. * * Parameters: * 0: the uri pointing to a first library * 1: the uri pointing to a second library */ static const StaticWarningCode EXPORT_DUPLICATED_LIBRARY_UNNAMED = const StaticWarningCode('EXPORT_DUPLICATED_LIBRARY_UNNAMED', "The exported libraries '{0}' and '{1}' cannot both be unnamed"); /** * 12.14.2 Binding Actuals to Formals: It is a static warning if m < * h or if m > n. * * Parameters: * 0: the maximum number of positional arguments * 1: the actual number of positional arguments given * * See [NOT_ENOUGH_REQUIRED_ARGUMENTS]. */ static const StaticWarningCode EXTRA_POSITIONAL_ARGUMENTS = const StaticWarningCode('EXTRA_POSITIONAL_ARGUMENTS', "{0} positional arguments expected, but {1} found"); /** * 5. Variables: It is a static warning if a final instance variable that has * been initialized at its point of declaration is also initialized in a * constructor. */ static const StaticWarningCode FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION = const StaticWarningCode( 'FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION', "Values cannot be set in the constructor if they are final, and have already been set"); /** * 5. Variables: It is a static warning if a final instance variable that has * been initialized at its point of declaration is also initialized in a * constructor. * * Parameters: * 0: the name of the field in question */ static const StaticWarningCode FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR = const StaticWarningCode( 'FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR', "'{0}' is final and was given a value when it was declared, so it cannot be set to a new value"); /** * 7.6.1 Generative Constructors: Execution of an initializer of the form * this.v = e proceeds as follows: First, the expression * e is evaluated to an object o. Then, the instance variable * v of the object denoted by this is bound to o. * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. * * Parameters: * 0: the name of the type of the initializer expression * 1: the name of the type of the field */ static const StaticWarningCode FIELD_INITIALIZER_NOT_ASSIGNABLE = const StaticWarningCode('FIELD_INITIALIZER_NOT_ASSIGNABLE', "The initializer type '{0}' cannot be assigned to the field type '{1}'"); /** * 7.6.1 Generative Constructors: An initializing formal has the form * this.id. It is a static warning if the static type of id is * not assignable to Tid. * * Parameters: * 0: the name of the type of the field formal parameter * 1: the name of the type of the field */ static const StaticWarningCode FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE = const StaticWarningCode('FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE', "The parameter type '{0}' is incompatable with the field type '{1}'"); /** * 5 Variables: It is a static warning if a library, static or local variable * v is final and v is not initialized at its point of * declaration. * * Parameters: * 0: the name of the uninitialized final variable */ static const StaticWarningCode FINAL_NOT_INITIALIZED = const StaticWarningCode('FINAL_NOT_INITIALIZED', "The final variable '{0}' must be initialized"); /** * 7.6.1 Generative Constructors: Each final instance variable f * declared in the immediately enclosing class must have an initializer in * k's initializer list unless it has already been initialized by one * of the following means: * * Initialization at the declaration of f. * * Initialization by means of an initializing formal of k. * or a static warning occurs. * * Parameters: * 0: the name of the uninitialized final variable */ static const StaticWarningCode FINAL_NOT_INITIALIZED_CONSTRUCTOR_1 = const StaticWarningCode('FINAL_NOT_INITIALIZED_CONSTRUCTOR_1', "The final variable '{0}' must be initialized"); /** * 7.6.1 Generative Constructors: Each final instance variable f * declared in the immediately enclosing class must have an initializer in * k's initializer list unless it has already been initialized by one * of the following means: * * Initialization at the declaration of f. * * Initialization by means of an initializing formal of k. * or a static warning occurs. * * Parameters: * 0: the name of the uninitialized final variable * 1: the name of the uninitialized final variable */ static const StaticWarningCode FINAL_NOT_INITIALIZED_CONSTRUCTOR_2 = const StaticWarningCode('FINAL_NOT_INITIALIZED_CONSTRUCTOR_2', "The final variables '{0}' and '{1}' must be initialized"); /** * 7.6.1 Generative Constructors: Each final instance variable f * declared in the immediately enclosing class must have an initializer in * k's initializer list unless it has already been initialized by one * of the following means: * * Initialization at the declaration of f. * * Initialization by means of an initializing formal of k. * or a static warning occurs. * * Parameters: * 0: the name of the uninitialized final variable * 1: the name of the uninitialized final variable * 2: the number of additional not initialized variables that aren't listed */ static const StaticWarningCode FINAL_NOT_INITIALIZED_CONSTRUCTOR_3_PLUS = const StaticWarningCode('FINAL_NOT_INITIALIZED_CONSTRUCTOR_3', "The final variables '{0}', '{1}' and '{2}' more must be initialized"); /** * 15.5 Function Types: It is a static warning if a concrete class implements * Function and does not have a concrete method named call(). */ static const StaticWarningCode FUNCTION_WITHOUT_CALL = const StaticWarningCode( 'FUNCTION_WITHOUT_CALL', "Concrete classes that implement Function must implement the method call()"); /** * 14.1 Imports: It is a static warning to import two different libraries with * the same name. * * Parameters: * 0: the uri pointing to a first library * 1: the uri pointing to a second library * 2: the shared name of the imported libraries */ static const StaticWarningCode IMPORT_DUPLICATED_LIBRARY_NAMED = const StaticWarningCode('IMPORT_DUPLICATED_LIBRARY_NAMED', "The imported libraries '{0}' and '{1}' cannot have the same name '{2}'"); /** * 14.1 Imports: It is a static warning to import two different libraries with * the same name. * * Parameters: * 0: the uri pointing to a first library * 1: the uri pointing to a second library */ static const StaticWarningCode IMPORT_DUPLICATED_LIBRARY_UNNAMED = const StaticWarningCode('IMPORT_DUPLICATED_LIBRARY_UNNAMED', "The imported libraries '{0}' and '{1}' cannot both be unnamed"); /** * 14.1 Imports: It is a static warning if the specified URI of a deferred * import does not refer to a library declaration. * * Parameters: * 0: the uri pointing to a non-library declaration * * See [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]. */ static const StaticWarningCode IMPORT_OF_NON_LIBRARY = const StaticWarningCode('IMPORT_OF_NON_LIBRARY', "The imported library '{0}' must not have a part-of directive"); /** * 8.1.1 Inheritance and Overriding: However, if the above rules would cause * multiple members m1, …, mk with the * same name n that would be inherited (because identically named * members existed in several superinterfaces) then at most one member is * inherited. * * If some but not all of the mi, 1 <= i <= k are * getters none of the mi are inherited, and a static * warning is issued. */ static const StaticWarningCode INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD = const StaticWarningCode( 'INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD', "'{0}' is inherited as a getter and also a method"); /** * 7.1 Instance Methods: It is a static warning if a class C declares * an instance method named n and an accessible static member named * n is declared in a superclass of C. * * Parameters: * 0: the name of the member with the name conflict * 1: the name of the enclosing class that has the static member */ static const StaticWarningCode INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC = const StaticWarningCode( 'INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC', "'{0}' collides with a static member in the superclass '{1}'"); /** * 7.2 Getters: It is a static warning if a getter m1 overrides a * getter m2 and the type of m1 is not a subtype of the type of * m2. * * Parameters: * 0: the name of the actual return type * 1: the name of the expected return type, not assignable to the actual * return type * 2: the name of the class where the overridden getter is declared * * See [INVALID_METHOD_OVERRIDE_RETURN_TYPE]. */ static const StaticWarningCode INVALID_GETTER_OVERRIDE_RETURN_TYPE = const StaticWarningCode('INVALID_GETTER_OVERRIDE_RETURN_TYPE', "The return type '{0}' is not assignable to '{1}' as required by the getter it is overriding from '{2}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance method m2 and the type of m1 * is not a subtype of the type of m2. * * Parameters: * 0: the name of the actual parameter type * 1: the name of the expected parameter type, not assignable to the actual * parameter type * 2: the name of the class where the overridden method is declared */ static const StaticWarningCode INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance method m2 and the type of m1 * is not a subtype of the type of m2. * * Parameters: * 0: the name of the actual parameter type * 1: the name of the expected parameter type, not assignable to the actual * parameter type * 2: the name of the class where the overridden method is declared * See [INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]. */ static const StaticWarningCode INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance method m2 and the type of m1 * is not a subtype of the type of m2. * * Parameters: * 0: the name of the actual parameter type * 1: the name of the expected parameter type, not assignable to the actual * parameter type * 2: the name of the class where the overridden method is declared */ static const StaticWarningCode INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance method m2 and the type of m1 * is not a subtype of the type of m2. * * Parameters: * 0: the name of the actual return type * 1: the name of the expected return type, not assignable to the actual * return type * 2: the name of the class where the overridden method is declared * * See [INVALID_GETTER_OVERRIDE_RETURN_TYPE]. */ static const StaticWarningCode INVALID_METHOD_OVERRIDE_RETURN_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_RETURN_TYPE', "The return type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance member m2, the signature of * m2 explicitly specifies a default value for a formal parameter * p and the signature of m1 specifies a different default value * for p. */ static const StaticWarningCode INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED = const StaticWarningCode('INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED', "Parameters cannot override default values, this method overrides '{0}.{1}' where '{2}' has a different value"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance member m2, the signature of * m2 explicitly specifies a default value for a formal parameter * p and the signature of m1 specifies a different default value * for p. */ static const StaticWarningCode INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL = const StaticWarningCode( 'INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL', "Parameters cannot override default values, this method overrides '{0}.{1}' where this positional parameter has a different value"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance member m2 and m1 does not * declare all the named parameters declared by m2. * * Parameters: * 0: the number of named parameters in the overridden member * 1: the name of the class from the overridden method */ static const StaticWarningCode INVALID_OVERRIDE_NAMED = const StaticWarningCode( 'INVALID_OVERRIDE_NAMED', "Missing the named parameter '{0}' to match the overridden method from '{1}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance member m2 and m1 has fewer * positional parameters than m2. * * Parameters: * 0: the number of positional parameters in the overridden member * 1: the name of the class from the overridden method */ static const StaticWarningCode INVALID_OVERRIDE_POSITIONAL = const StaticWarningCode('INVALID_OVERRIDE_POSITIONAL', "Must have at least {0} parameters to match the overridden method from '{1}'"); /** * 7.1 Instance Methods: It is a static warning if an instance method * m1 overrides an instance member m2 and m1 has a * greater number of required parameters than m2. * * Parameters: * 0: the number of required parameters in the overridden member * 1: the name of the class from the overridden method */ static const StaticWarningCode INVALID_OVERRIDE_REQUIRED = const StaticWarningCode('INVALID_OVERRIDE_REQUIRED', "Must have {0} required parameters or less to match the overridden method from '{1}'"); /** * 7.3 Setters: It is a static warning if a setter m1 overrides a * setter m2 and the type of m1 is not a subtype of the type of * m2. * * Parameters: * 0: the name of the actual parameter type * 1: the name of the expected parameter type, not assignable to the actual * parameter type * 2: the name of the class where the overridden setter is declared * * See [INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]. */ static const StaticWarningCode INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE = const StaticWarningCode('INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the setter it is overriding from '{2}'"); /** * 12.6 Lists: A run-time list literal <E> [e1 * … en] is evaluated as follows: * * The operator []= is invoked on a with first argument i and * second argument oi+1, 1 <= i <= n * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. */ static const StaticWarningCode LIST_ELEMENT_TYPE_NOT_ASSIGNABLE = const StaticWarningCode('LIST_ELEMENT_TYPE_NOT_ASSIGNABLE', "The element type '{0}' cannot be assigned to the list type '{1}'"); /** * 12.7 Map: A run-time map literal <K, V> * [k1 : e1 … kn * : en] is evaluated as follows: * * The operator []= is invoked on m with first argument * ki and second argument ei, 1 <= * i <= n * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. */ static const StaticWarningCode MAP_KEY_TYPE_NOT_ASSIGNABLE = const StaticWarningCode('MAP_KEY_TYPE_NOT_ASSIGNABLE', "The element type '{0}' cannot be assigned to the map key type '{1}'"); /** * 12.7 Map: A run-time map literal <K, V> * [k1 : e1 … kn * : en] is evaluated as follows: * * The operator []= is invoked on m with first argument * ki and second argument ei, 1 <= * i <= n * * 12.14.2 Binding Actuals to Formals: Let Ti be the static * type of ai, let Si be the type of * pi, 1 <= i <= n+k and let Sq be * the type of the named parameter q of f. It is a static * warning if Tj may not be assigned to Sj, 1 * <= j <= m. */ static const StaticWarningCode MAP_VALUE_TYPE_NOT_ASSIGNABLE = const StaticWarningCode('MAP_VALUE_TYPE_NOT_ASSIGNABLE', "The element type '{0}' cannot be assigned to the map value type '{1}'"); /** * 7.3 Setters: It is a static warning if a class has a setter named v= * with argument type T and a getter named v with return type * S, and T may not be assigned to S. */ static const StaticWarningCode MISMATCHED_GETTER_AND_SETTER_TYPES = const StaticWarningCode('MISMATCHED_GETTER_AND_SETTER_TYPES', "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}')"); /** * 7.3 Setters: It is a static warning if a class has a setter named v= * with argument type T and a getter named v with return type * S, and T may not be assigned to S. */ static const StaticWarningCode MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE = const StaticWarningCode( 'MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE', "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}'), from superclass '{3}'"); /** * 13.12 Return: It is a static warning if a function contains both one or * more return statements of the form return; and one or more return * statements of the form return e;. */ static const StaticWarningCode MIXED_RETURN_TYPES = const StaticWarningCode( 'MIXED_RETURN_TYPES', "Methods and functions cannot use return both with and without values"); /** * 12.11.1 New: It is a static warning if q is a constructor of an * abstract class and q is not a factory constructor. */ static const StaticWarningCode NEW_WITH_ABSTRACT_CLASS = const StaticWarningCode('NEW_WITH_ABSTRACT_CLASS', "Abstract classes cannot be created with a 'new' expression"); /** * 15.8 Parameterized Types: Any use of a malbounded type gives rise to a * static warning. * * Parameters: * 0: the name of the type being referenced (S) * 1: the number of type parameters that were declared * 2: the number of type arguments provided * * See [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS], and * [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]. */ static const StaticWarningCode NEW_WITH_INVALID_TYPE_PARAMETERS = const StaticWarningCode('NEW_WITH_INVALID_TYPE_PARAMETERS', "The type '{0}' is declared with {1} type parameters, but {2} type arguments were given"); /** * 12.11.1 New: It is a static warning if T is not a class accessible * in the current scope, optionally followed by type arguments. * * Parameters: * 0: the name of the non-type element */ static const StaticWarningCode NEW_WITH_NON_TYPE = const StaticWarningCode( 'NEW_WITH_NON_TYPE', "The name '{0}' is not a class"); /** * 12.11.1 New: If T is a class or parameterized type accessible in the * current scope then: * 1. If e is of the form new T.id(a1, …, * an, xn+1: an+1, …, * xn+k: an+k) it is a static warning if * T.id is not the name of a constructor declared by the type * T. * If e of the form new T(a1, …, an, * xn+1: an+1, …, xn+k: * an+kM/sub>) it is a static warning if the type T does not * declare a constructor with the same name as the declaration of T. */ static const StaticWarningCode NEW_WITH_UNDEFINED_CONSTRUCTOR = const StaticWarningCode('NEW_WITH_UNDEFINED_CONSTRUCTOR', "The class '{0}' does not have a constructor '{1}'"); /** * 12.11.1 New: If T is a class or parameterized type accessible in the * current scope then: * 1. If e is of the form new T.id(a1, …, * an, xn+1: an+1, …, xn+k: * an+k) it is a static warning if T.id is not the name * of a constructor declared by the type T. If e of the form * new T(a1, …, an, xn+1: * an+1, …, xn+k: an+kM/sub>) it is a * static warning if the type T does not declare a constructor with the * same name as the declaration of T. */ static const StaticWarningCode NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT = const StaticWarningCode('NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT', "The class '{0}' does not have a default constructor"); /** * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract * class inherits an abstract method. * * 7.10 Superinterfaces: Let C be a concrete class that does not * declare its own noSuchMethod() method. It is a static warning if the * implicit interface of C includes an instance member m of type * F and C does not declare or inherit a corresponding instance * member m of type F' such that F' <: F. * * 7.4 Abstract Instance Members: It is a static warning if an abstract member * is declared or inherited in a concrete class unless that member overrides a * concrete one. * * Parameters: * 0: the name of the first member * 1: the name of the second member * 2: the name of the third member * 3: the name of the fourth member * 4: the number of additional missing members that aren't listed */ static const StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS = const StaticWarningCode( 'NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS', "Missing concrete implementation of {0}, {1}, {2}, {3} and {4} more"); /** * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract * class inherits an abstract method. * * 7.10 Superinterfaces: Let C be a concrete class that does not * declare its own noSuchMethod() method. It is a static warning if the * implicit interface of C includes an instance member m of type * F and C does not declare or inherit a corresponding instance * member m of type F' such that F' <: F. * * 7.4 Abstract Instance Members: It is a static warning if an abstract member * is declared or inherited in a concrete class unless that member overrides a * concrete one. * * Parameters: * 0: the name of the first member * 1: the name of the second member * 2: the name of the third member * 3: the name of the fourth member */ static const StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR = const StaticWarningCode( 'NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR', "Missing concrete implementation of {0}, {1}, {2} and {3}"); /** * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract * class inherits an abstract method. * * 7.10 Superinterfaces: Let C be a concrete class that does not * declare its own noSuchMethod() method. It is a static warning if the * implicit interface of C includes an instance member m of type * F and C does not declare or inherit a corresponding instance * member m of type F' such that F' <: F. * * 7.4 Abstract Instance Members: It is a static warning if an abstract member * is declared or inherited in a concrete class unless that member overrides a * concrete one. * * Parameters: * 0: the name of the member */ static const StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE = const StaticWarningCode('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE', "Missing concrete implementation of {0}"); /** * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract * class inherits an abstract method. * * 7.10 Superinterfaces: Let C be a concrete class that does not * declare its own noSuchMethod() method. It is a static warning if the * implicit interface of C includes an instance member m of type * F and C does not declare or inherit a corresponding instance * member m of type F' such that F' <: F. * * 7.4 Abstract Instance Members: It is a static warning if an abstract member * is declared or inherited in a concrete class unless that member overrides a * concrete one. * * Parameters: * 0: the name of the first member * 1: the name of the second member * 2: the name of the third member */ static const StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE = const StaticWarningCode( 'NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE', "Missing concrete implementation of {0}, {1} and {2}"); /** * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract * class inherits an abstract method. * * 7.10 Superinterfaces: Let C be a concrete class that does not * declare its own noSuchMethod() method. It is a static warning if the * implicit interface of C includes an instance member m of type * F and C does not declare or inherit a corresponding instance * member m of type F' such that F' <: F. * * 7.4 Abstract Instance Members: It is a static warning if an abstract member * is declared or inherited in a concrete class unless that member overrides a * concrete one. * * Parameters: * 0: the name of the first member * 1: the name of the second member */ static const StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO = const StaticWarningCode('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO', "Missing concrete implementation of {0} and {1}"); /** * 13.11 Try: An on-catch clause of the form on T catch (p1, * p2) s or on T s matches an object o if the * type of o is a subtype of T. It is a static warning if * T does not denote a type available in the lexical scope of the * catch clause. * * Parameters: * 0: the name of the non-type element */ static const StaticWarningCode NON_TYPE_IN_CATCH_CLAUSE = const StaticWarningCode('NON_TYPE_IN_CATCH_CLAUSE', "The name '{0}' is not a type and cannot be used in an on-catch clause"); /** * 7.1.1 Operators: It is a static warning if the return type of the * user-declared operator []= is explicitly declared and not void. */ static const StaticWarningCode NON_VOID_RETURN_FOR_OPERATOR = const StaticWarningCode('NON_VOID_RETURN_FOR_OPERATOR', "The return type of the operator []= must be 'void'"); /** * 7.3 Setters: It is a static warning if a setter declares a return type * other than void. */ static const StaticWarningCode NON_VOID_RETURN_FOR_SETTER = const StaticWarningCode('NON_VOID_RETURN_FOR_SETTER', "The return type of the setter must be 'void'"); /** * 15.1 Static Types: A type T is malformed iff: * * T has the form id or the form prefix.id, and in the * enclosing lexical scope, the name id (respectively * prefix.id) does not denote a type. * * T denotes a type parameter in the enclosing lexical scope, but * occurs in the signature or body of a static member. * * T is a parameterized type of the form G<S1, .., * Sn>, * * Any use of a malformed type gives rise to a static warning. * * Parameters: * 0: the name that is not a type */ static const StaticWarningCode NOT_A_TYPE = const StaticWarningCode('NOT_A_TYPE', "{0} is not a type"); /** * 12.14.2 Binding Actuals to Formals: It is a static warning if m < * h or if m > n. * * Parameters: * 0: the expected number of required arguments * 1: the actual number of positional arguments given * * See [EXTRA_POSITIONAL_ARGUMENTS]. */ static const StaticWarningCode NOT_ENOUGH_REQUIRED_ARGUMENTS = const StaticWarningCode('NOT_ENOUGH_REQUIRED_ARGUMENTS', "{0} required argument(s) expected, but {1} found"); /** * 14.3 Parts: It is a static warning if the referenced part declaration * p names a library other than the current library as the library to * which p belongs. * * Parameters: * 0: the name of expected library name * 1: the non-matching actual library name from the "part of" declaration */ static const StaticWarningCode PART_OF_DIFFERENT_LIBRARY = const StaticWarningCode('PART_OF_DIFFERENT_LIBRARY', "Expected this library to be part of '{0}', not '{1}'"); /** * 7.6.2 Factories: It is a static warning if the function type of k' * is not a subtype of the type of k. * * Parameters: * 0: the name of the redirected constructor * 1: the name of the redirecting constructor */ static const StaticWarningCode REDIRECT_TO_INVALID_FUNCTION_TYPE = const StaticWarningCode('REDIRECT_TO_INVALID_FUNCTION_TYPE', "The redirected constructor '{0}' has incompatible parameters with '{1}'"); /** * 7.6.2 Factories: It is a static warning if the function type of k' * is not a subtype of the type of k. * * Parameters: * 0: the name of the redirected constructor return type * 1: the name of the redirecting constructor return type */ static const StaticWarningCode REDIRECT_TO_INVALID_RETURN_TYPE = const StaticWarningCode('REDIRECT_TO_INVALID_RETURN_TYPE', "The return type '{0}' of the redirected constructor is not assignable to '{1}'"); /** * 7.6.2 Factories: It is a static warning if type does not denote a class * accessible in the current scope; if type does denote such a class C * it is a static warning if the referenced constructor (be it type or * type.id) is not a constructor of C. */ static const StaticWarningCode REDIRECT_TO_MISSING_CONSTRUCTOR = const StaticWarningCode('REDIRECT_TO_MISSING_CONSTRUCTOR', "The constructor '{0}' could not be found in '{1}'"); /** * 7.6.2 Factories: It is a static warning if type does not denote a class * accessible in the current scope; if type does denote such a class C * it is a static warning if the referenced constructor (be it type or * type.id) is not a constructor of C. */ static const StaticWarningCode REDIRECT_TO_NON_CLASS = const StaticWarningCode( 'REDIRECT_TO_NON_CLASS', "The name '{0}' is not a type and cannot be used in a redirected constructor"); /** * 13.12 Return: Let f be the function immediately enclosing a return * statement of the form return; It is a static warning if both of the * following conditions hold: * * f is not a generative constructor. * * The return type of f may not be assigned to void. */ static const StaticWarningCode RETURN_WITHOUT_VALUE = const StaticWarningCode( 'RETURN_WITHOUT_VALUE', "Missing return value after 'return'"); /** * 12.16.3 Static Invocation: It is a static warning if C does not * declare a static method or getter m. * * Parameters: * 0: the name of the instance member */ static const StaticWarningCode STATIC_ACCESS_TO_INSTANCE_MEMBER = const StaticWarningCode('STATIC_ACCESS_TO_INSTANCE_MEMBER', "Instance member '{0}' cannot be accessed using static access"); /** * 13.9 Switch: It is a static warning if the type of e may not be * assigned to the type of ek. */ static const StaticWarningCode SWITCH_EXPRESSION_NOT_ASSIGNABLE = const StaticWarningCode('SWITCH_EXPRESSION_NOT_ASSIGNABLE', "Type '{0}' of the switch expression is not assignable to the type '{1}' of case expressions"); /** * 15.1 Static Types: It is a static warning to use a deferred type in a type * annotation. * * Parameters: * 0: the name of the type that is deferred and being used in a type * annotation */ static const StaticWarningCode TYPE_ANNOTATION_DEFERRED_CLASS = const StaticWarningCode('TYPE_ANNOTATION_DEFERRED_CLASS', "The deferred type '{0}' cannot be used in a declaration, cast or type test"); /** * 12.31 Type Test: It is a static warning if T does not denote a type * available in the current lexical scope. */ static const StaticWarningCode TYPE_TEST_WITH_NON_TYPE = const StaticWarningCode( 'TYPE_TEST_WITH_NON_TYPE', "The name '{0}' is not a type and cannot be used in an 'is' expression"); /** * 12.31 Type Test: It is a static warning if T does not denote a type * available in the current lexical scope. */ static const StaticWarningCode TYPE_TEST_WITH_UNDEFINED_NAME = const StaticWarningCode('TYPE_TEST_WITH_UNDEFINED_NAME', "The name '{0}' is not defined and cannot be used in an 'is' expression"); /** * 10 Generics: However, a type parameter is considered to be a malformed type * when referenced by a static member. * * 15.1 Static Types: Any use of a malformed type gives rise to a static * warning. A malformed type is then interpreted as dynamic by the static type * checker and the runtime. */ static const StaticWarningCode TYPE_PARAMETER_REFERENCED_BY_STATIC = const StaticWarningCode('TYPE_PARAMETER_REFERENCED_BY_STATIC', "Static members cannot reference type parameters"); /** * 12.16.3 Static Invocation: A static method invocation i has the form * C.m(a1, …, an, xn+1: * an+1, … xn+k: an+k). It is a * static warning if C does not denote a class in the current scope. * * Parameters: * 0: the name of the undefined class */ static const StaticWarningCode UNDEFINED_CLASS = const StaticWarningCode('UNDEFINED_CLASS', "Undefined class '{0}'"); /** * Same as [UNDEFINED_CLASS], but to catch using "boolean" instead of "bool". */ static const StaticWarningCode UNDEFINED_CLASS_BOOLEAN = const StaticWarningCode('UNDEFINED_CLASS_BOOLEAN', "Undefined class 'boolean'; did you mean 'bool'?"); /** * 12.17 Getter Invocation: It is a static warning if there is no class * C in the enclosing lexical scope of i, or if C does * not declare, implicitly or explicitly, a getter named m. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the getter is being looked for */ static const StaticWarningCode UNDEFINED_GETTER = const StaticWarningCode( 'UNDEFINED_GETTER', "The getter '{0}' is not defined for the class '{1}'"); /** * 12.30 Identifier Reference: It is as static warning if an identifier * expression of the form id occurs inside a top level or static * function (be it function, method, getter, or setter) or variable * initializer and there is no declaration d with name id in the * lexical scope enclosing the expression. * * Parameters: * 0: the name of the identifier */ static const StaticWarningCode UNDEFINED_IDENTIFIER = const StaticWarningCode('UNDEFINED_IDENTIFIER', "Undefined name '{0}'"); /** * 12.14.2 Binding Actuals to Formals: Furthermore, each qi, * 1<=i<=l, must have a corresponding named parameter in the set * {pn+1 … pn+k} or a static * warning occurs. * * Parameters: * 0: the name of the requested named parameter */ static const StaticWarningCode UNDEFINED_NAMED_PARAMETER = const StaticWarningCode('UNDEFINED_NAMED_PARAMETER', "The named parameter '{0}' is not defined"); /** * 12.18 Assignment: It is as static warning if an assignment of the form * v = e occurs inside a top level or static function (be it function, * method, getter, or setter) or variable initializer and there is no * declaration d with name v= in the lexical scope enclosing the * assignment. * * 12.18 Assignment: It is a static warning if there is no class C in * the enclosing lexical scope of the assignment, or if C does not * declare, implicitly or explicitly, a setter v=. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the setter is being looked for */ static const StaticWarningCode UNDEFINED_SETTER = const StaticWarningCode( 'UNDEFINED_SETTER', "The setter '{0}' is not defined for the class '{1}'"); /** * 12.16.3 Static Invocation: It is a static warning if C does not * declare a static method or getter m. * * Parameters: * 0: the name of the method * 1: the name of the enclosing type where the method is being looked for */ static const StaticWarningCode UNDEFINED_STATIC_METHOD_OR_GETTER = const StaticWarningCode('UNDEFINED_STATIC_METHOD_OR_GETTER', "The static method, getter or setter '{0}' is not defined for the class '{1}'"); /** * 12.17 Getter Invocation: It is a static warning if there is no class * C in the enclosing lexical scope of i, or if C does * not declare, implicitly or explicitly, a getter named m. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the getter is being looked for */ static const StaticWarningCode UNDEFINED_SUPER_GETTER = const StaticWarningCode('UNDEFINED_SUPER_GETTER', "The getter '{0}' is not defined in a superclass of '{1}'"); /** * 12.18 Assignment: It is as static warning if an assignment of the form * v = e occurs inside a top level or static function (be it function, * method, getter, or setter) or variable initializer and there is no * declaration d with name v= in the lexical scope enclosing the * assignment. * * 12.18 Assignment: It is a static warning if there is no class C in * the enclosing lexical scope of the assignment, or if C does not * declare, implicitly or explicitly, a setter v=. * * Parameters: * 0: the name of the getter * 1: the name of the enclosing type where the setter is being looked for */ static const StaticWarningCode UNDEFINED_SUPER_SETTER = const StaticWarningCode('UNDEFINED_SUPER_SETTER', "The setter '{0}' is not defined in a superclass of '{1}'"); /** * 7.2 Getters: It is a static warning if the return type of a getter is void. */ static const StaticWarningCode VOID_RETURN_FOR_GETTER = const StaticWarningCode('VOID_RETURN_FOR_GETTER', "The return type of the getter must not be 'void'"); /** * Initialize a newly created error code to have the given [name]. The message * associated with the error will be created from the given [message] * template. The correction associated with the error will be created from the * given [correction] template. */ const StaticWarningCode(String name, String message, [String correction]) : super(name, message, correction); @override ErrorSeverity get errorSeverity => ErrorType.STATIC_WARNING.severity; @override ErrorType get type => ErrorType.STATIC_WARNING; } /** * The error code indicating a marker in code for work that needs to be finished * or revisited. */ class TodoCode extends ErrorCode { /** * The single enum of TodoCode. */ static const TodoCode TODO = const TodoCode('TODO'); /** * This matches the two common Dart task styles * * * TODO: * * TODO(username): * * As well as * * TODO * * But not * * todo * * TODOS */ static RegExp TODO_REGEX = new RegExp("([\\s/\\*])((TODO[^\\w\\d][^\\r\\n]*)|(TODO:?\$))"); /** * Initialize a newly created error code to have the given [name]. */ const TodoCode(String name) : super(name, "{0}"); @override ErrorSeverity get errorSeverity => ErrorSeverity.INFO; @override ErrorType get type => ErrorType.TODO; }