Removed fixed dependencies

packages/analyzer/lib/src/error/codes.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;
+library analyzer.src.error.codes;
 
-import 'dart:collection';
-
-import 'ast.dart' show AstNode;
-import 'element.dart';
-import 'java_core.dart';
-import 'scanner.dart' show Token;
-import 'source.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 
 /**
- * An error discovered during the analysis of some Dart code.
- *
- * See [AnalysisErrorListener].
+ * The error codes used for errors in analysis options 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 AnalysisError {
+class AnalysisOptionsErrorCode extends ErrorCode {
   /**
-   * An empty array of errors used when no errors are expected.
+   * An error code indicating that there is a syntactic error in the file.
+   *
+   * Parameters:
+   * 0: the error message from the parse error
    */
-  static const List<AnalysisError> NO_ERRORS = const <AnalysisError>[];
+  static const AnalysisOptionsErrorCode PARSE_ERROR =
+      const AnalysisOptionsErrorCode('PARSE_ERROR', '{0}');
 
   /**
-   * A [Comparator] that sorts by the name of the file that the [AnalysisError]
-   * was found.
+   * Initialize a newly created error code to have the given [name].
    */
-  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;
-    if (errorSeverity1 == errorSeverity2) {
-      ErrorType errorType1 = errorCode1.type;
-      ErrorType errorType2 = errorCode2.type;
-      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. The error is associated with the
-   * given [source] and is located 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(this.source, this.offset, this.length, this.errorCode,
-      [List<Object> arguments]) {
-    this._message = formatList(errorCode.message, arguments);
-    String correctionTemplate = errorCode.correction;
-    if (correctionTemplate != null) {
-      this._correction = formatList(correctionTemplate, arguments);
-    }
-  }
-
-  /**
-   * 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.
-   */
-  @deprecated // Use new AnalysisError(source, 0, 0, errorCode, arguments)
-  AnalysisError.con1(Source source, ErrorCode errorCode,
-      [List<Object> arguments])
-      : this(source, 0, 0, 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.
-   */
-  @deprecated // Use new AnalysisError(source, offset, length, errorCode, arguments)
-  AnalysisError.con2(Source source, int offset, int length, ErrorCode errorCode,
-      [List<Object> arguments])
-      : this(source, offset, length, errorCode, 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;
+  const AnalysisOptionsErrorCode(String name, String message,
+      [String correction])
+      : super(name, message, correction);
 
   @override
-  int get hashCode {
-    int hashCode = offset;
-    hashCode ^= (_message != null) ? _message.hashCode : 0;
-    hashCode ^= (source != null) ? source.hashCode : 0;
-    return hashCode;
-  }
-
-  /**
-   * 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;
+  ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @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();
-  }
-
-  /**
-   * Merge all of the errors in the lists in the given list of [errorLists] into
-   * a single list of errors.
-   */
-  static List<AnalysisError> mergeLists(List<List<AnalysisError>> errorLists) {
-    Set<AnalysisError> errors = new HashSet<AnalysisError>();
-    for (List<AnalysisError> errorList in errorLists) {
-      errors.addAll(errorList);
-    }
-    return errors.toList();
-  }
+  ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
 }
 
 /**
- * An object that listen for [AnalysisError]s being produced by the analysis
- * engine.
+ * The error codes used for warnings in analysis options 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.
  */
-abstract class AnalysisErrorListener {
+class AnalysisOptionsWarningCode extends ErrorCode {
   /**
-   * An error listener that ignores errors that are reported to it.
+   * An error code indicating that a plugin is being configured with an
+   * unsupported option and legal options are provided.
+   *
+   * Parameters:
+   * 0: the plugin name
+   * 1: the unsupported option key
+   * 2: legal values
    */
-  static final AnalysisErrorListener NULL_LISTENER =
-      new AnalysisErrorListener_NULL_LISTENER();
+  static const AnalysisOptionsWarningCode UNSUPPORTED_OPTION_WITH_LEGAL_VALUES =
+      const AnalysisOptionsWarningCode('UNSUPPORTED_OPTION_WITH_LEGAL_VALUES',
+          "The option '{1}' is not supported by {0}, supported values are {2}");
 
   /**
-   * This method is invoked when an [error] has been found by the analysis
-   * engine.
+   * An error code indicating that a plugin is being configured with an
+   * unsupported option where there is just one legal value.
+   *
+   * Parameters:
+   * 0: the plugin name
+   * 1: the unsupported option key
+   * 2: the legal value
    */
-  void onError(AnalysisError error);
+  static const AnalysisOptionsWarningCode UNSUPPORTED_OPTION_WITH_LEGAL_VALUE =
+      const AnalysisOptionsWarningCode('UNSUPPORTED_OPTION_WITH_LEGAL_VALUE',
+          "The option '{1}' is not supported by {0}, did you mean {2}?");
+
+  /**
+   * An error code indicating that an option entry is being configured with an
+   * unsupported value.
+   *
+   * Parameters:
+   * 0: the option name
+   * 1: the unsupported value
+   * 2: legal values
+   */
+  static const AnalysisOptionsWarningCode UNSUPPORTED_VALUE =
+      const AnalysisOptionsWarningCode('UNSUPPORTED_VALUE',
+          "The value '{1}' is not supported by {0}, legal values are {2}");
+
+  /**
+   * An error code indicating that an unrecognized error code is being used to
+   * specify an error filter.
+   *
+   * Parameters:
+   * 0: the unrecognized error code
+   */
+  static const AnalysisOptionsWarningCode UNRECOGNIZED_ERROR_CODE =
+      const AnalysisOptionsWarningCode(
+          'UNRECOGNIZED_ERROR_CODE', "'{0}' is not a recognized error code");
+
+  /**
+   * Initialize a newly created warning code to have the given [name].
+   */
+  const AnalysisOptionsWarningCode(String name, String message,
+      [String correction])
+      : super(name, message, correction);
+
+  @override
+  ErrorSeverity get errorSeverity => ErrorSeverity.WARNING;
+
+  @override
+  ErrorType get type => ErrorType.STATIC_WARNING;
 }
 
 /**
- * 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. The error is associated with the
-   * given [source] and is located 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(
-      Source source, int offset, int length, ErrorCode errorCode,
-      [List<Object> arguments])
-      : super(source, offset, length, errorCode, arguments);
-
-  /**
-   * 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.
-   */
-  @deprecated // Use new AnalysisErrorWithProperties(source, 0, 0, errorCode, arguments)
-  AnalysisErrorWithProperties.con1(Source source, ErrorCode errorCode,
-      [List<Object> arguments])
-      : this(source, 0, 0, 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.
-   */
-  @deprecated // Use new AnalysisErrorWithProperties(source, offset, length, errorCode, arguments)
-  AnalysisErrorWithProperties.con2(
-      Source source, int offset, int length, ErrorCode errorCode,
-      [List<Object> arguments])
-      : this(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 =
+  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 =
+  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 <b>null</b> and the interface of the class of <i>o</i> is not a
    * subtype of the static type of the field <i>v</i>.
    *
    * 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 =
+  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 &lt;<i>E</i>&gt; [<i>e<sub>1</sub></i>
    * ... <i>e<sub>n</sub></i>] is evaluated as follows:
    * * The operator []= is invoked on <i>a</i> with first argument <i>i</i> and
    *   second argument <i>o<sub>i+1</sub></i><i>, 1 &lt;= i &lt;= n</i>
    *
    * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static
    * type of <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of
    * <i>p<sub>i</sub>, 1 &lt;= i &lt;= n+k</i> and let <i>S<sub>q</sub></i> be
    * the type of the named parameter <i>q</i> of <i>f</i>. It is a static
    * warning if <i>T<sub>j</sub></i> may not be assigned to <i>S<sub>j</sub>,
    * 1 &lt;= j &lt;= m</i>.
    */
-  static const CheckedModeCompileTimeErrorCode LIST_ELEMENT_TYPE_NOT_ASSIGNABLE =
-      const CheckedModeCompileTimeErrorCode('LIST_ELEMENT_TYPE_NOT_ASSIGNABLE',
+  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 &lt;<i>K</i>, <i>V</i>&gt;
    * [<i>k<sub>1</sub></i> : <i>e<sub>1</sub></i> ... <i>k<sub>n</sub></i> :
    * <i>e<sub>n</sub></i>] is evaluated as follows:
    * * The operator []= is invoked on <i>m</i> with first argument
    *   <i>k<sub>i</sub></i> and second argument <i>e<sub>i</sub></i><i>, 1 &lt;=
    *   i &lt;= n</i>
    *
@@ skipping 77 matching lines @@
    * 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}'");
 
   /**
+   * 15 Metadata: The constant expression given in an annotation is type checked
+   * and evaluated in the scope surrounding the declaration being annotated.
+   *
+   * 12.11.2 Const: It is a compile-time error if <i>T</i> is not a class
+   * accessible in the current scope, optionally followed by type arguments.
+   *
+   * 12.11.2 Const: If <i>e</i> is of the form <i>const T.id(a<sub>1</sub>,
+   * &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip;
+   * x<sub>n+k</sub>: a<sub>n+k</sub>)</i> it is a compile-time error if
+   * <i>T</i> 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 ANNOTATION_WITH_NON_CLASS =
+      const CompileTimeErrorCode(
+          'ANNOTATION_WITH_NON_CLASS', "The name '{0}' is not a class");
+
+  /**
    * 12.33 Argument Definition Test: It is a compile time error if <i>v</i> 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");
@@ skipping 129 matching lines @@
    */
   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 =
+  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.
    *
@@ skipping 47 matching lines @@
       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 =
+  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
    * <i>==</i> unless the key is a string or integer.
    */
-  static const CompileTimeErrorCode CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS =
+  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
@@ skipping 58 matching lines @@
   /**
    * 12.11.2 Const: If <i>T</i> is a parameterized type <i>S&lt;U<sub>1</sub>,
    * &hellip;, U<sub>m</sub>&gt;</i>, let <i>R = S</i>; It is a compile time
    * error if <i>S</i> is not a generic type with <i>m</i> type parameters.
    *
    * Parameters:
    * 0: the name of the type being referenced (<i>S</i>)
    * 1: the number of type parameters that were declared
    * 2: the number of type arguments provided
    *
-   * See [CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS], and
+   * See [StaticWarningCode.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 <i>e</i> is of the form <i>const T(a<sub>1</sub>,
    * &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip;,
    * x<sub>n+k</sub>: a<sub>n+k</sub>)</i> it is a compile-time error if the
@@ skipping 76 matching lines @@
    * 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 <i>k</i> explicitly
    * specifies a default value for an optional parameter.
    */
-  static const CompileTimeErrorCode DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR =
+  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',
@@ skipping 129 matching lines @@
    * 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}'");
 
   /**
+   * DEP 37 extends the syntax for assert() to allow a second "message"
+   * argument.  We issue this error if the user tries to supply a "message"
+   * argument but the DEP is not enabled.
+   */
+  static const CompileTimeErrorCode EXTRA_ARGUMENT_TO_ASSERT =
+      const CompileTimeErrorCode('EXTRA_ARGUMENT_TO_ASSERT',
+          "Assertions only accept a single argument");
+
+  /**
    * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt;
    * h</i> or if <i>m &gt; n</i>.
    *
    * 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 <i>k</i> be a generative constructor. It
    * is a compile time error if more than one initializer corresponding to a
    * given instance variable appears in <i>k</i>'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 <i>k</i> be a generative constructor. It
    * is a compile time error if <i>k</i>'s initializer list contains an
    * initializer for a variable that is initialized by means of an initializing
    * formal of <i>k</i>.
    */
-  static const CompileTimeErrorCode FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER =
+  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:
@@ skipping 460 matching lines @@
           "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 <i>e</i> is an enumerated typed with elements
-   *   <i>id<sub>1</sub></i>, &hellip;, <i>id<sub>n</sub></i>.
-   * * The sets {<i>e<sub>1</sub></i>, &hellip;, <i>e<sub>k</sub></i>} and
-   *   {<i>id<sub>1</sub></i>, &hellip;, <i>id<sub>n</sub></i>} 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");
 
@@ skipping 90 matching lines @@
    * 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',
+  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 <i>k</i> be a generative constructor.
    * Then <i>k</i> 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");
@@ skipping 66 matching lines @@
    * e<sub>n</sub>: s<sub>n</sub> default: s<sub>n+1</sub>}</i> or the form
    * <i>switch (e) { label<sub>11</sub> &hellip; label<sub>1j1</sub> case
    * e<sub>1</sub>: s<sub>1</sub> &hellip; label<sub>n1</sub> &hellip;
    * label<sub>njn</sub> case e<sub>n</sub>: s<sub>n</sub>}</i>, it is a
    * compile-time error if the expressions <i>e<sub>k</sub></i> are not
    * compile-time constants, for all <i>1 &lt;= k &lt;= n</i>.
    *
    * 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 =
+  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 =
+  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 =
+  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(
@@ skipping 18 matching lines @@
       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',
+  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].
@@ skipping 12 matching lines @@
           "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 =
+  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 <i>m < h</i>
    * or if <i>m > n</i>.
    *
    * 12.11.2 Const: It is a compile-time error if evaluation of a constant
    * object results in an uncaught exception being thrown.
@@ skipping 122 matching lines @@
    *
    * 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 <i>C</i> 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 =
+  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 <i>C</i> 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 <i>C</i> 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 =
+  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 <i>C</i> 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 <i>C</i> 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 =
+  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 <i>k</i> is prefixed with
    * the const modifier but <i>k'</i> is not a constant constructor.
    */
   static const CompileTimeErrorCode REDIRECT_TO_MISSING_CONSTRUCTOR =
       const CompileTimeErrorCode('REDIRECT_TO_MISSING_CONSTRUCTOR',
@@ skipping 22 matching lines @@
    */
   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
    * <i>redirecting</i>, in which case its only action is to invoke another
    * generative constructor.
    */
-  static const CompileTimeErrorCode REDIRECT_GENERATIVE_TO_NON_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");
+          "Local variable '{0}' cannot be referenced before it is declared");
 
   /**
    * 12.8.1 Rethrow: It is a compile-time error if an expression of the form
    * <i>rethrow;</i> 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");
+          'RETHROW_OUTSIDE_CATCH',
+          "Rethrow must be inside of catch clause.",
+          "Try moving the expression into a catch clause, or using a 'throw' expression.");
 
   /**
    * 13.12 Return: It is a compile-time error if a return statement of the form
    * <i>return e;</i> appears in a generative constructor.
    */
   static const CompileTimeErrorCode RETURN_IN_GENERATIVE_CONSTRUCTOR =
-      const CompileTimeErrorCode('RETURN_IN_GENERATIVE_CONSTRUCTOR',
-          "Constructors cannot return a value");
+      const CompileTimeErrorCode(
+          'RETURN_IN_GENERATIVE_CONSTRUCTOR',
+          "Constructors can't return values.",
+          "Try removing the return statement or using a factory constructor.");
 
   /**
    * 13.12 Return: It is a compile-time error if a return statement of the form
    * <i>return e;</i> 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*')");
+  static const CompileTimeErrorCode RETURN_IN_GENERATOR = const CompileTimeErrorCode(
+      'RETURN_IN_GENERATOR',
+      "Can't return a value from a generator function (using the '{0}' modifier).",
+      "Try removing the value, replacing 'return' with 'yield' or changing the method body modifier.");
 
   /**
    * 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");
 
   /**
@@ skipping 74 matching lines @@
       const CompileTimeErrorCode('UNDEFINED_CONSTRUCTOR_IN_INITIALIZER',
           "The class '{0}' does not have a generative constructor '{1}'");
 
   /**
    * 7.6.1 Generative Constructors: Let <i>C</i> be the class in which the
    * superinitializer appears and let <i>S</i> be the superclass of <i>C</i>.
    * Let <i>k</i> be a generative constructor. It is a compile-time error if
    * class <i>S</i> does not declare a generative constructor named <i>S</i>
    * (respectively <i>S.id</i>)
    */
-  static const CompileTimeErrorCode UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT =
-      const CompileTimeErrorCode('UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT',
+  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 <i>q<sub>i</sub></i>,
    * <i>1<=i<=l</i>, must have a corresponding named parameter in the set
    * {<i>p<sub>n+1</sub></i> ... <i>p<sub>n+k</sub></i>} 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.
@@ skipping 11 matching lines @@
    *
    * 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].
+   * See [INVALID_URI], [URI_HAS_NOT_BEEN_GENERATED].
    */
   static const CompileTimeErrorCode URI_DOES_NOT_EXIST =
       const CompileTimeErrorCode(
           'URI_DOES_NOT_EXIST', "Target of URI does not exist: '{0}'");
 
   /**
+   * Just like [URI_DOES_NOT_EXIST], but used when the URI refers to a file that
+   * is expected to be generated.
+   *
+   * Parameters:
+   * 0: the URI pointing to a non-existent file
+   *
+   * See [INVALID_URI], [URI_DOES_NOT_EXIST].
+   */
+  static const CompileTimeErrorCode URI_HAS_NOT_BEEN_GENERATED =
+      const CompileTimeErrorCode('URI_HAS_NOT_BEEN_GENERATED',
+          "Target of URI has not been generated: '{0}'");
+
+  /**
    * 14.1 Imports: It is a compile-time error if <i>x</i> is not a compile-time
    * constant, or if <i>x</i> involves string interpolation.
    *
    * 14.3 Parts: It is a compile-time error if <i>s</i> is not a compile-time
    * constant, or if <i>s</i> involves string interpolation.
    *
    * 14.5 URIs: It is a compile-time error if the string literal <i>x</i> that
    * describes a URI is not a compile-time constant, or if <i>x</i> involves
    * string interpolation.
    */
@@ skipping 19 matching lines @@
       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 =
+  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 <i>p</i>.
    */
   static const CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER =
       const CompileTimeErrorCode('WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER',
@@ skipping 25 matching lines @@
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorType.COMPILE_TIME_ERROR.severity;
 
   @override
   ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
 }
 
 /**
- * An error listener that can be enabled or disabled while executing a function.
- */
-class DisablableErrorListener implements AnalysisErrorListener {
-  /**
-   * The listener to which errors will be reported if this listener is enabled.
-   */
-  final AnalysisErrorListener baseListener;
-
-  /**
-   * A flag indicating whether this listener is currently enabled.
-   */
-  bool enabled = true;
-
-  /**
-   * Initialize a newly created listener to report errors to the given
-   * [baseListener].
-   */
-  DisablableErrorListener(this.baseListener);
-
-  /**
-   * Disable the processing of errors while evaluating the given [function].
-   * Return the value returned by the function.
-   */
-  dynamic disableWhile(dynamic function()) {
-    bool wasEnabled = enabled;
-    try {
-      enabled = false;
-      return function();
-    } finally {
-      enabled = wasEnabled;
-    }
-  }
-
-  /**
-   * Disable the processing of errors while evaluating the given [function].
-   * Return the value returned by the function.
-   */
-  dynamic enableWhile(dynamic function()) {
-    bool wasEnabled = enabled;
-    try {
-      enabled = true;
-      return function();
-    } finally {
-      enabled = wasEnabled;
-    }
-  }
-
-  @override
-  void onError(AnalysisError error) {
-    if (enabled) {
-      baseListener.onError(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(
-          _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]) {
-    int length = 0;
-    if (element is ImportElement) {
-      length = 6; // 'import'.length
-    } else if (element is ExportElement) {
-      length = 6; // 'export'.length
-    } else {
-      length = element.nameLength;
-    }
-    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(_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 {
   /**
+   * When an abstract supertype member is references with `super` as its target,
+   * it cannot be overridden, so it is always a runtime error.
+   *
+   * Parameters:
+   * 0: the display name for the kind of the referenced element
+   * 1: the name of the referenced element
+   */
+  static const HintCode ABSTRACT_SUPER_MEMBER_REFERENCE = const HintCode(
+      'ABSTRACT_SUPER_MEMBER_REFERENCE',
+      "The {0} '{1}' is always abstract in the supertype.",
+      null);
+
+  /**
    * 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}'");
+      "The argument type '{0}' cannot be assigned to the parameter type '{1}'.",
+      null);
+
+  /**
+   * When the target expression uses '?.' operator, it can be `null`, so all the
+   * subsequent invocations should also use '?.' operator.
+   */
+  static const HintCode CAN_BE_NULL_AFTER_NULL_AWARE = const HintCode(
+      'CAN_BE_NULL_AFTER_NULL_AWARE',
+      "The expression uses '?.', so can be 'null'",
+      "Replace the '.' with a '?.' in the invocation");
 
   /**
    * 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)`.
@@ skipping 75 matching lines @@
    *
    * 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}'");
 
   /**
+   * This hint is generated anywhere a @factory annotation is associated with
+   * anything other than a method.
+   */
+  static const HintCode INVALID_FACTORY_ANNOTATION = const HintCode(
+      'INVALID_FACTORY_ANNOTATION',
+      "Only methods can be annotated as factories.");
+
+  /**
+   * This hint is generated anywhere a @factory annotation is associated with
+   * a method that does not declare a return type.
+   */
+  static const HintCode INVALID_FACTORY_METHOD_DECL = const HintCode(
+      'INVALID_FACTORY_METHOD_DECL',
+      "Factory method '{0}' must have a return type.");
+
+  /**
+   * This hint is generated anywhere a @factory annotation is associated with
+   * a non-abstract method that can return anything other than a newly allocated
+   * object.
+   *
+   * Parameters:
+   * 0: the name of the method
+   */
+  static const HintCode INVALID_FACTORY_METHOD_IMPL = const HintCode(
+      'INVALID_FACTORY_METHOD_IMPL',
+      "Factory method '{0}' does not return a newly allocated object.");
+
+  /**
+   * This hint is generated anywhere where a member annotated with `@protected`
+   * is used outside an instance member of a subclass.
+   *
+   * Parameters:
+   * 0: the name of the member
+   * 1: the name of the defining class
+   */
+  static const HintCode INVALID_USE_OF_PROTECTED_MEMBER = const HintCode(
+      'INVALID_USE_OF_PROTECTED_MEMBER',
+      "The member '{0}' can only be used within instance members of subclasses of '{1}'");
+
+  /**
+   * Generate a hint for a constructor, function or method invocation where a
+   * required parameter is missing.
+   *
+   * Parameters:
+   * 0: the name of the parameter
+   */
+  static const HintCode MISSING_REQUIRED_PARAM = const HintCode(
+      'MISSING_REQUIRED_PARAM', "The parameter '{0}' is required.");
+
+  /**
+   * Generate a hint for a constructor, function or method invocation where a
+   * required parameter is missing.
+   *
+   * Parameters:
+   * 0: the name of the parameter
+   * 1: message details
+   */
+  static const HintCode MISSING_REQUIRED_PARAM_WITH_DETAILS = const HintCode(
+      'MISSING_REQUIRED_PARAM_WITH_DETAILS',
+      "The parameter '{0}' is required. {1}");
+
+  /**
+   * Generate a hint for an element that is annotated with `@JS(...)` whose
+   * library declaration is not similarly annotated.
+   */
+  static const HintCode MISSING_JS_LIB_ANNOTATION = const HintCode(
+      'MISSING_JS_LIB_ANNOTATION',
+      "The @JS() annotation can only be used if it is also declared on the library directive.");
+
+  /**
    * 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'");
 
   /**
+   * Generate a hint for methods that override methods annotated `@mustCallSuper`
+   * that do not invoke the overridden super method.
+   *
+   * Parameters:
+   * 0: the name of the class declaring the overriden method
+   */
+  static const HintCode MUST_CALL_SUPER = const HintCode(
+      'MUST_CALL_SUPER',
+      "This method overrides a method annotated as @mustCall super in '{0}', "
+      "but does invoke the overriden method");
+
+  /**
+   * A condition in a control flow statement could evaluate to `null` because it
+   * uses the null-aware '?.' operator.
+   */
+  static const HintCode NULL_AWARE_IN_CONDITION = const HintCode(
+      'NULL_AWARE_IN_CONDITION',
+      "The value of the '?.' operator can be 'null', which is not appropriate in a condition",
+      "Replace the '?.' with a '.', testing the left-hand side for null if necessary");
+
+  /**
    * 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 field with the override annotation does not override a getter or setter.
+   */
+  static const HintCode OVERRIDE_ON_NON_OVERRIDING_FIELD = const HintCode(
+      'OVERRIDE_ON_NON_OVERRIDING_FIELD',
+      "Field does not override an inherited getter or setter");
+
+  /**
    * 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(
@@ skipping 27 matching lines @@
    * 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}'");
+      "The getter '{0}' is not defined for the class '{1}'.", null);
+
+  /**
+   * An undefined name hidden in an import or export directive.
+   */
+  static const HintCode UNDEFINED_HIDDEN_NAME = const HintCode(
+      'UNDEFINED_HIDDEN_NAME',
+      "The library '{0}' doesn't export a member with the hidden name '{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}'");
+      "The method '{0}' is not defined for the class '{1}'.", null);
 
   /**
    * 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}'");
+      "The operator '{0}' is not defined for the class '{1}'.",
+      null);
 
   /**
    * 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}'");
+      "The setter '{0}' is not defined for the class '{1}'.", null);
+
+  /**
+   * An undefined name shown in an import or export directive.
+   */
+  static const HintCode UNDEFINED_SHOWN_NAME = const HintCode(
+      'UNDEFINED_SHOWN_NAME',
+      "The library '{0}' doesn't export a member with the shown name '{1}'");
 
   /**
    * Unnecessary cast.
    */
   static const HintCode UNNECESSARY_CAST =
       const HintCode('UNNECESSARY_CAST', "Unnecessary cast");
 
   /**
+   * Unnecessary `noSuchMethod` declaration.
+   */
+  static const HintCode UNNECESSARY_NO_SUCH_METHOD = const HintCode(
+      'UNNECESSARY_NO_SUCH_METHOD', "Unnecessary 'noSuchMethod' declaration");
+
+  /**
    * 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(
@@ skipping 33 matching lines @@
       "The stack trace variable '{0}' is not used and can be removed");
 
   /**
    * Unused local variables are local variables 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");
 
   /**
+   * Unused shown names are names shown on imports which are never used.
+   */
+  static const HintCode UNUSED_SHOWN_NAME = const HintCode(
+      'UNUSED_SHOWN_NAME', "The name {0} is shown, but 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'");
 
@@ skipping 349 matching lines @@
    * static types of both of <i>e<sub>1</sub></i> and <i>e<sub>2</sub></i> 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'");
 
+  static const StaticTypeWarningCode NON_NULLABLE_FIELD_NOT_INITIALIZED =
+      const StaticTypeWarningCode('NON_NULLABLE_FIELD_NOT_INITIALIZED',
+          "Variable '{0}' of non-nullable type '{1}' must be initialized");
+
   /**
    * 15.8 Parameterized Types: It is a static type warning if <i>A<sub>i</sub>,
    * 1 &lt;= i &lt;= n</i> 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 <i>e</i> 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}'");
+      const StaticTypeWarningCode(
+          'RETURN_OF_INVALID_TYPE',
+          "The return type '{0}' is not a '{1}', as defined by the method '{2}'.",
+          null);
 
   /**
    * 12.11 Instance Creation: It is a static type warning if any of the type
    * arguments to a constructor of a generic type <i>G</i> invoked by a new
    * expression or a constant object expression are not subtypes of the bounds
    * of the corresponding formal type parameters of <i>G</i>.
    *
    * 15.8 Parameterized Types: If <i>S</i> is the static type of a member
    * <i>m</i> of <i>G</i>, then the static type of the member <i>m</i> of
    * <i>G&lt;A<sub>1</sub>, &hellip;, A<sub>n</sub>&gt;</i> is <i>[A<sub>1</sub>,
@@ skipping 37 matching lines @@
    * 12.17 Getter Invocation: It is a static warning if there is no class
    * <i>C</i> in the enclosing lexical scope of <i>i</i>, or if <i>C</i> does
    * not declare, implicitly or explicitly, a getter named <i>m</i>.
    *
    * 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}'");
+          "There is no constant named '{0}' in '{1}'.", null);
 
   /**
    * 12.15.3 Unqualified Invocation: If there exists a lexically visible
    * declaration named <i>id</i>, let <i>f<sub>id</sub></i> be the innermost
    * such declaration. Then: [skip]. Otherwise, <i>f<sub>id</sub></i> is
    * considered equivalent to the ordinary method invocation
    * <b>this</b>.<i>id</i>(<i>a<sub>1</sub></i>, ..., <i>a<sub>n</sub></i>,
    * <i>x<sub>n+1</sub></i> : <i>a<sub>n+1</sub></i>, ...,
    * <i>x<sub>n+k</sub></i> : <i>a<sub>n+k</sub></i>).
    *
    * 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");
+          'UNDEFINED_FUNCTION', "The function '{0}' is not defined.", null);
 
   /**
    * 12.17 Getter Invocation: Let <i>T</i> be the static type of <i>e</i>. It is
    * a static type warning if <i>T</i> does not have a getter named <i>m</i>.
    *
    * 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}'");
+          "The getter '{0}' is not defined for the class '{1}'.", null);
 
   /**
    * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance member named <i>m</i>.
    *
    * 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}'");
+          "The method '{0}' is not defined for the class '{1}'.", null);
+
+  /**
+   * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>.
+   * It is a static type warning if <i>T</i> does not have an accessible
+   * instance member named <i>m</i>.
+   *
+   * 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_WITH_CONSTRUCTOR =
+      const StaticTypeWarningCode(
+          'UNDEFINED_METHOD_WITH_CONSTRUCTOR',
+          "The method '{0}' is not defined for the class '{1}', but a constructor with that name is defined.",
+          "Try adding 'new' or 'const' to invoke the constuctor, or change the method name.");
 
   /**
    * 12.18 Assignment: Evaluation of an assignment of the form
    * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] = <i>e<sub>3</sub></i> is
    * equivalent to the evaluation of the expression (a, i, e){a.[]=(i, e);
    * return e;} (<i>e<sub>1</sub></i>, <i>e<sub>2</sub></i>,
    * <i>e<sub>2</sub></i>).
    *
    * 12.29 Assignable Expressions: An assignable expression of the form
    * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] is evaluated as a method
    * invocation of the operator method [] on <i>e<sub>1</sub></i> with argument
    * <i>e<sub>2</sub></i>.
    *
    * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance member named <i>m</i>.
    *
    * 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}'");
+          "The operator '{0}' is not defined for the class '{1}'.", null);
 
   /**
    * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance setter named <i>v=</i>.
    *
    * 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}'");
+          "The setter '{0}' is not defined for the class '{1}'.", null);
 
   /**
    * 12.17 Getter Invocation: Let <i>T</i> be the static type of <i>e</i>. It is
    * a static type warning if <i>T</i> does not have a getter named <i>m</i>.
    *
    * 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}'");
+          "The getter '{0}' is not defined in a superclass of '{1}'.", null);
 
   /**
    * 12.15.4 Super Invocation: A super method invocation <i>i</i> has the form
    * <i>super.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>:
    * a<sub>n+1</sub>, &hellip; x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. It is a
    * static type warning if <i>S</i> does not have an accessible instance member
    * named <i>m</i>.
    *
    * 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}'");
+          "The method '{0}' is not defined in a superclass of '{1}'.", null);
 
   /**
    * 12.18 Assignment: Evaluation of an assignment of the form
    * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] = <i>e<sub>3</sub></i> is
    * equivalent to the evaluation of the expression (a, i, e){a.[]=(i, e);
    * return e;} (<i>e<sub>1</sub></i>, <i>e<sub>2</sub></i>,
    * <i>e<sub>2</sub></i>).
    *
    * 12.29 Assignable Expressions: An assignable expression of the form
    * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] is evaluated as a method
    * invocation of the operator method [] on <i>e<sub>1</sub></i> with argument
    * <i>e<sub>2</sub></i>.
    *
    * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance member named <i>m</i>.
    *
    * 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}'");
+          "The operator '{0}' is not defined in a superclass of '{1}'.", null);
 
   /**
    * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance setter named <i>v=</i>.
    *
    * 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}'");
+          "The setter '{0}' is not defined in a superclass of '{1}'.", null);
 
   /**
    * 12.15.1 Ordinary Invocation: It is a static type warning if <i>T</i> does
    * not have an accessible (3.2) instance member named <i>m</i>.
    *
    * 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 =
+  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 <i>G</i> is not a
    * generic type with exactly <i>n</i> type parameters.
    *
    * Parameters:
    * 0: the name of the type being referenced (<i>G</i>)
@@ skipping 23 matching lines @@
    * 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}'");
 
   /**
+   * 17.6.2 For-in. If the iterable expression does not implement Iterable,
+   * this warning is reported.
+   *
+   * Parameters:
+   * 0: The type of the iterable expression.
+   * 1: The sequence type -- Iterable for `for` or Stream for `await for`.
+   */
+  static const StaticTypeWarningCode FOR_IN_OF_INVALID_TYPE =
+      const StaticTypeWarningCode('FOR_IN_OF_INVALID_TYPE',
+          "The type '{0}' used in the 'for' loop must implement {1}");
+
+  /**
+   * 17.6.2 For-in. It the iterable expression does not implement Iterable with
+   * a type argument that can be assigned to the for-in variable's type, this
+   * warning is reported.
+   *
+   * Parameters:
+   * 0: The type of the iterable expression.
+   * 1: The sequence type -- Iterable for `for` or Stream for `await for`.
+   * 2: The loop variable type.
+   */
+  static const StaticTypeWarningCode FOR_IN_OF_INVALID_ELEMENT_TYPE =
+      const StaticTypeWarningCode('FOR_IN_OF_INVALID_ELEMENT_TYPE',
+          "The type '{0}' used in the 'for' loop must implement {1} with a type argument that can be assigned to '{2}'");
+
+  /**
    * 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;
@@ skipping 52 matching lines @@
    * <i>{p<sub>n+1</sub>, &hellip; p<sub>n+k</sub>}</i> or a static warning
    * occurs. It is a static warning if <i>T<sub>m+j</sub></i> may not be
    * assigned to <i>S<sub>r</sub></i>, where <i>r = q<sub>j</sub>, 1 &lt;= j
    * &lt;= l</i>.
    *
    * 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}'");
+      const StaticWarningCode(
+          'ARGUMENT_TYPE_NOT_ASSIGNABLE',
+          "The argument type '{0}' cannot be assigned to the parameter type '{1}'.",
+          null);
 
   /**
    * 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");
@@ skipping 73 matching lines @@
    * 14.1 Imports: If a name <i>N</i> is referenced by a library <i>L</i> and
    * <i>N</i> would be introduced into the top level scope of <i>L</i> by an
    * import from a library whose URI begins with <i>dart:</i> and an import from
    * a library whose URI does not begin with <i>dart:</i>:
    * * The import from <i>dart:</i> 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
+   * 2: 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 <i>C</i> declares an
    * instance getter named <i>v</i> and an accessible static member named
    * <i>v</i> or <i>v=</i> is declared in a superclass of <i>C</i>.
    *
    * Parameters:
    * 0: the name of the super class declaring a static member
    */
-  static const StaticWarningCode CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_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 <i>C</i> declares
    * an instance method named <i>n</i> and has a setter named <i>n=</i>.
    */
   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 <i>C</i> declares
    * an instance method named <i>n</i> and has a setter named <i>n=</i>.
    */
   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 <i>C</i> declares an
    * instance setter named <i>v=</i> and an accessible static member named
    * <i>v=</i> or <i>v</i> is declared in a superclass of <i>C</i>.
    *
    * Parameters:
    * 0: the name of the super class declaring a static member
    */
-  static const StaticWarningCode CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_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 <i>v</i> and also has a non-static setter named <i>v=</i>.
    */
   static const StaticWarningCode CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER =
       const StaticWarningCode('CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER',
@@ skipping 49 matching lines @@
    */
   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 =
+  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 =
+  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
    * <b>this</b>.<i>v</i> = <i>e</i> proceeds as follows: First, the expression
    * <i>e</i> is evaluated to an object <i>o</i>. Then, the instance variable
    * <i>v</i> of the object denoted by this is bound to <i>o</i>.
    *
@@ skipping 28 matching lines @@
   /**
    * 5 Variables: It is a static warning if a library, static or local variable
    * <i>v</i> is final and <i>v</i> 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");
+          "The final variable '{0}' must be initialized", null, false);
 
   /**
    * 7.6.1 Generative Constructors: Each final instance variable <i>f</i>
    * declared in the immediately enclosing class must have an initializer in
    * <i>k</i>'s initializer list unless it has already been initialized by one
    * of the following means:
    * * Initialization at the declaration of <i>f</i>.
    * * Initialization by means of an initializing formal of <i>k</i>.
    * 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");
+          "The final variable '{0}' must be initialized", null, false);
 
   /**
    * 7.6.1 Generative Constructors: Each final instance variable <i>f</i>
    * declared in the immediately enclosing class must have an initializer in
    * <i>k</i>'s initializer list unless it has already been initialized by one
    * of the following means:
    * * Initialization at the declaration of <i>f</i>.
    * * Initialization by means of an initializing formal of <i>k</i>.
    * 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");
+      const StaticWarningCode(
+          'FINAL_NOT_INITIALIZED_CONSTRUCTOR_2',
+          "The final variables '{0}' and '{1}' must be initialized",
+          null,
+          false);
 
   /**
    * 7.6.1 Generative Constructors: Each final instance variable <i>f</i>
    * declared in the immediately enclosing class must have an initializer in
    * <i>k</i>'s initializer list unless it has already been initialized by one
    * of the following means:
    * * Initialization at the declaration of <i>f</i>.
    * * Initialization by means of an initializing formal of <i>k</i>.
    * 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");
+      const StaticWarningCode(
+          'FINAL_NOT_INITIALIZED_CONSTRUCTOR_3',
+          "The final variables '{0}', '{1}' and '{2}' more must be initialized",
+          null,
+          false);
 
   /**
    * 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()");
 
   /**
@@ skipping 26 matching lines @@
    * 8.1.1 Inheritance and Overriding: However, if the above rules would cause
    * multiple members <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i> with the
    * same name <i>n</i> 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 <i>m<sub>i</sub>, 1 &lt;= i &lt;= k</i> are
    * getters none of the <i>m<sub>i</sub></i> are inherited, and a static
    * warning is issued.
    */
-  static const StaticWarningCode INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD =
+  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 <i>C</i> declares
    * an instance method named <i>n</i> and an accessible static member named
    * <i>n</i> is declared in a superclass of <i>C</i>.
    *
    * 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 =
+  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 <i>m1</i> overrides a
    * getter <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of
    * <i>m2</i>.
    *
    * Parameters:
@@ skipping 17 matching lines @@
    * 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}'");
 
   /**
+   * Generic Method DEP: number of type parameters must match.
+   * <https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md#function-subtyping>
+   *
+   * Parameters:
+   * 0: the number of type parameters in the method
+   * 1: the number of type parameters in the overridden method
+   * 2: the name of the class where the overridden method is declared
+   */
+  static const StaticWarningCode INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS =
+      const StaticWarningCode('INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS',
+          "The method has {0} type parameters, but it is overriding a method with {1} type parameters from '{2}'");
+
+  /**
+   * Generic Method DEP: bounds of type parameters must be compatible.
+   * <https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md#function-subtyping>
+   *
+   * Parameters:
+   * 0: the type parameter name
+   * 1: the type parameter bound
+   * 2: the overridden type parameter name
+   * 3: the overridden type parameter bound
+   * 4: the name of the class where the overridden method is declared
+   */
+  static const StaticWarningCode INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND =
+      const StaticWarningCode('INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND',
+          "The type parameter '{0}' extends '{1}', but that is stricter than '{2}' extends '{3}' in the overridden method from '{4}'");
+
+  /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
    * is not a subtype of the type of <i>m2</i>.
    *
    * 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].
@@ skipping 34 matching lines @@
       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
    * <i>m1</i> overrides an instance member <i>m2</i>, the signature of
    * <i>m2</i> explicitly specifies a default value for a formal parameter
    * <i>p</i> and the signature of <i>m1</i> specifies a different default value
    * for <i>p</i>.
    */
-  static const StaticWarningCode INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED =
-      const StaticWarningCode('INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED',
+  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
    * <i>m1</i> overrides an instance member <i>m2</i>, the signature of
    * <i>m2</i> explicitly specifies a default value for a formal parameter
    * <i>p</i> and the signature of <i>m1</i> specifies a different default value
    * for <i>p</i>.
    */
-  static const StaticWarningCode INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL =
+  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
    * <i>m1</i> overrides an instance member <i>m2</i> and <i>m1</i> does not
    * declare all the named parameters declared by <i>m2</i>.
    *
    * Parameters:
    * 0: the number of named parameters in the overridden member
-   * 1: the name of the class from the overridden method
+   * 1: the signature of the overridden member
+   * 2: 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}'");
+      "Missing the named parameter '{0}' to match the overridden method from '{1}' from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance member <i>m2</i> and <i>m1</i> has fewer
    * positional parameters than <i>m2</i>.
    *
    * Parameters:
    * 0: the number of positional parameters in the overridden member
-   * 1: the name of the class from the overridden method
+   * 1: the signature of the overridden member
+   * 2: 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}'");
+          "Must have at least {0} parameters to match the overridden method '{1}' from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance member <i>m2</i> and <i>m1</i> has a
    * greater number of required parameters than <i>m2</i>.
    *
    * Parameters:
    * 0: the number of required parameters in the overridden member
-   * 1: the name of the class from the overridden method
+   * 1: the signature of the overridden member
+   * 2: 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}'");
+          "Must have {0} required parameters or less to match the overridden method '{1}' from '{2}'");
 
   /**
    * 7.3 Setters: It is a static warning if a setter <i>m1</i> overrides a
    * setter <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of
    * <i>m2</i>.
    *
    * Parameters:
    * 0: the name of the actual parameter type
    * 1: the name of the expected parameter type, not assignable to the actual
    * parameter type
@@ skipping 59 matching lines @@
   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 <i>v=</i>
    * with argument type <i>T</i> and a getter named <i>v</i> with return type
    * <i>S</i>, and <i>T</i> may not be assigned to <i>S</i>.
    */
   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}')");
+      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}')",
+          null,
+          false);
 
   /**
    * 7.3 Setters: It is a static warning if a class has a setter named <i>v=</i>
    * with argument type <i>T</i> and a getter named <i>v</i> with return type
    * <i>S</i>, and <i>T</i> may not be assigned to <i>S</i>.
    */
-  static const StaticWarningCode MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE =
+  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}'");
+          "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}'), from superclass '{3}'",
+          null,
+          false);
+
+  /**
+   * 17.9 Switch: 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 <i>e</i> is an enumerated typed with elements
+   *   <i>id<sub>1</sub></i>, &hellip;, <i>id<sub>n</sub></i>.
+   * * The sets {<i>e<sub>1</sub></i>, &hellip;, <i>e<sub>k</sub></i>} and
+   *   {<i>id<sub>1</sub></i>, &hellip;, <i>id<sub>n</sub></i>} are not the
+   *   same.
+   *
+   * Parameters:
+   * 0: the name of the constant that is missing
+   */
+  static const StaticWarningCode MISSING_ENUM_CONSTANT_IN_SWITCH =
+      const StaticWarningCode(
+          'MISSING_ENUM_CONSTANT_IN_SWITCH',
+          "Missing case clause for '{0}'",
+          "Add a case clause for the missing constant or add a default clause.",
+          false);
 
   /**
    * 13.12 Return: It is a static warning if a function contains both one or
    * more return statements of the form <i>return;</i> and one or more return
    * statements of the form <i>return e;</i>.
    */
   static const StaticWarningCode MIXED_RETURN_TYPES = const StaticWarningCode(
       'MIXED_RETURN_TYPES',
-      "Methods and functions cannot use return both with and without values");
+      "Methods and functions cannot use return both with and without values",
+      null,
+      false);
 
   /**
    * 12.11.1 New: It is a static warning if <i>q</i> is a constructor of an
    * abstract class and <i>q</i> 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");
 
   /**
@@ skipping 69 matching lines @@
    * 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 =
+  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 <i>C</i> be a concrete class that does not
    * declare its own <i>noSuchMethod()</i> method. It is a static warning if the
    * implicit interface of <i>C</i> includes an instance member <i>m</i> of type
    * <i>F</i> and <i>C</i> does not declare or inherit a corresponding instance
    * member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
    *
    * 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 =
+  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 <i>C</i> be a concrete class that does not
    * declare its own <i>noSuchMethod()</i> method. It is a static warning if the
    * implicit interface of <i>C</i> includes an instance member <i>m</i> of type
    * <i>F</i> and <i>C</i> does not declare or inherit a corresponding instance
    * member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
    *
    * 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',
+  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 <i>C</i> be a concrete class that does not
    * declare its own <i>noSuchMethod()</i> method. It is a static warning if the
    * implicit interface of <i>C</i> includes an instance member <i>m</i> of type
    * <i>F</i> and <i>C</i> does not declare or inherit a corresponding instance
    * member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
    *
    * 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 =
+  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 <i>C</i> be a concrete class that does not
    * declare its own <i>noSuchMethod()</i> method. It is a static warning if the
    * implicit interface of <i>C</i> includes an instance member <i>m</i> of type
    * <i>F</i> and <i>C</i> does not declare or inherit a corresponding instance
    * member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
    *
    * 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',
+  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 <i>on T catch (p<sub>1</sub>,
    * p<sub>2</sub>) s</i> or <i>on T s</i> matches an object <i>o</i> if the
    * type of <i>o</i> is a subtype of <i>T</i>. It is a static warning if
    * <i>T</i> 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'");
+          "The return type of the operator []= must be 'void'", null, false);
 
   /**
    * 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'");
+          "The return type of the setter must be 'void'", null, false);
 
   /**
    * 15.1 Static Types: A type <i>T</i> is malformed iff:
    * * <i>T</i> has the form <i>id</i> or the form <i>prefix.id</i>, and in the
    *   enclosing lexical scope, the name <i>id</i> (respectively
    *   <i>prefix.id</i>) does not denote a type.
    * * <i>T</i> denotes a type parameter in the enclosing lexical scope, but
    * occurs in the signature or body of a static member.
    * * <i>T</i> is a parameterized type of the form <i>G&lt;S<sub>1</sub>, ..,
    * S<sub>n</sub>&gt;</i>,
@@ skipping 78 matching lines @@
       "The name '{0}' is not a type and cannot be used in a redirected constructor");
 
   /**
    * 13.12 Return: Let <i>f</i> be the function immediately enclosing a return
    * statement of the form <i>return;</i> It is a static warning if both of the
    * following conditions hold:
    * * <i>f</i> is not a generative constructor.
    * * The return type of <i>f</i> may not be assigned to void.
    */
   static const StaticWarningCode RETURN_WITHOUT_VALUE = const StaticWarningCode(
-      'RETURN_WITHOUT_VALUE', "Missing return value after 'return'");
+      'RETURN_WITHOUT_VALUE',
+      "Missing return value after 'return'",
+      null,
+      false);
 
   /**
    * 12.16.3 Static Invocation: It is a static warning if <i>C</i> does not
    * declare a static method or getter <i>m</i>.
    *
    * Parameters:
    * 0: the name of the instance member
    */
   static const StaticWarningCode STATIC_ACCESS_TO_INSTANCE_MEMBER =
       const StaticWarningCode('STATIC_ACCESS_TO_INSTANCE_MEMBER',
@@ skipping 38 matching lines @@
   /**
    * 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");
+          "Static members cannot reference type parameters of the class");
 
   /**
    * 12.16.3 Static Invocation: A static method invocation <i>i</i> has the form
    * <i>C.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>:
    * a<sub>n+1</sub>, &hellip; x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. It is a
    * static warning if <i>C</i> does not denote a class in the current scope.
    *
    * Parameters:
    * 0: the name of the undefined class
    */
@@ skipping 11 matching lines @@
    * 12.17 Getter Invocation: It is a static warning if there is no class
    * <i>C</i> in the enclosing lexical scope of <i>i</i>, or if <i>C</i> does
    * not declare, implicitly or explicitly, a getter named <i>m</i>.
    *
    * 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}'");
+      "The getter '{0}' is not defined for the class '{1}'.",
+      null);
 
   /**
    * 12.30 Identifier Reference: It is as static warning if an identifier
    * expression of the form <i>id</i> occurs inside a top level or static
    * function (be it function, method, getter, or setter) or variable
    * initializer and there is no declaration <i>d</i> with name <i>id</i> 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}'");
 
   /**
+   * If the identifier is 'await', be helpful about it.
+   */
+  static const StaticWarningCode UNDEFINED_IDENTIFIER_AWAIT =
+      const StaticWarningCode('UNDEFINED_IDENTIFIER_AWAIT',
+          "Undefined name 'await'; did you mean to add the 'async' marker to '{0}'?");
+
+  /**
    * 12.14.2 Binding Actuals to Formals: Furthermore, each <i>q<sub>i</sub></i>,
    * <i>1<=i<=l</i>, must have a corresponding named parameter in the set
    * {<i>p<sub>n+1</sub></i> &hellip; <i>p<sub>n+k</sub></i>} 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
    * <i>v = e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer and there is no
    * declaration <i>d</i> with name <i>v=</i> in the lexical scope enclosing the
    * assignment.
    *
    * 12.18 Assignment: It is a static warning if there is no class <i>C</i> in
    * the enclosing lexical scope of the assignment, or if <i>C</i> does not
    * declare, implicitly or explicitly, a setter <i>v=</i>.
    *
    * 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}'");
+      "The setter '{0}' is not defined for the class '{1}'.",
+      null);
 
   /**
    * 12.16.3 Static Invocation: It is a static warning if <i>C</i> does not
    * declare a static method or getter <i>m</i>.
    *
    * 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
    * <i>C</i> in the enclosing lexical scope of <i>i</i>, or if <i>C</i> does
    * not declare, implicitly or explicitly, a getter named <i>m</i>.
    *
    * 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}'");
+          "The getter '{0}' is not defined in a superclass of '{1}'.", null);
 
   /**
    * 12.18 Assignment: It is as static warning if an assignment of the form
    * <i>v = e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer and there is no
    * declaration <i>d</i> with name <i>v=</i> in the lexical scope enclosing the
    * assignment.
    *
    * 12.18 Assignment: It is a static warning if there is no class <i>C</i> in
    * the enclosing lexical scope of the assignment, or if <i>C</i> does not
    * declare, implicitly or explicitly, a setter <i>v=</i>.
    *
    * 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}'");
+          "The setter '{0}' is not defined in a superclass of '{1}'.", null);
 
   /**
    * 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'");
+          "The return type of the getter must not be 'void'", null, false);
+
+  /**
+   * A flag indicating whether this warning is an error when running with strong
+   * mode enabled.
+   */
+  final bool isStrongModeError;
 
   /**
    * 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])
+  const StaticWarningCode(String name, String message,
+      [String correction, this.isStrongModeError = true])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorType.STATIC_WARNING.severity;
 
   @override
   ErrorType get type => ErrorType.STATIC_WARNING;
 }
 
 /**
+ * This class has Strong Mode specific error codes.
+ *
+ * These error codes tend to use the same message across different severity
+ * levels, so they are grouped for clarity.
+ *
+ * All of these error codes also use the "STRONG_MODE_" prefix in their name.
+ */
+class StrongModeCode extends ErrorCode {
+  static const String _implicitCastMessage =
+      'Unsound implicit cast from {0} to {1}';
+
+  static const String _unsafeBlockClosureInferenceMessage =
+      'Unsafe use of block closure in a type-inferred variable outside a '
+      'function body.  Workaround: add a type annotation for `{0}`.  See '
+      'dartbug.com/26947';
+
+  static const String _typeCheckMessage =
+      'Type check failed: {0} is not of type {1}';
+
+  static const String _invalidOverrideMessage =
+      'The type of {0}.{1} ({2}) is not a '
+      'subtype of {3}.{1} ({4}).';
+
+  /**
+   * This is appended to the end of an error message about implicit dynamic.
+   *
+   * The idea is to make sure the user is aware that this error message is the
+   * result of turning on a particular option, and they are free to turn it
+   * back off.
+   */
+  static const String _implicitDynamicTip =
+      ". Either add an explicit type like 'dynamic'"
+      ", or enable implicit-dynamic in your Analyzer options.";
+
+  static const String _inferredTypeMessage = '{0} has inferred type {1}';
+
+  static const StrongModeCode DOWN_CAST_COMPOSITE = const StrongModeCode(
+      ErrorType.STATIC_WARNING, 'DOWN_CAST_COMPOSITE', _implicitCastMessage);
+
+  static const StrongModeCode DOWN_CAST_IMPLICIT = const StrongModeCode(
+      ErrorType.HINT, 'DOWN_CAST_IMPLICIT', _implicitCastMessage);
+
+  static const StrongModeCode DOWN_CAST_IMPLICIT_ASSIGN = const StrongModeCode(
+      ErrorType.HINT, 'DOWN_CAST_IMPLICIT_ASSIGN', _implicitCastMessage);
+
+  static const StrongModeCode DYNAMIC_CAST = const StrongModeCode(
+      ErrorType.HINT, 'DYNAMIC_CAST', _implicitCastMessage);
+
+  static const StrongModeCode ASSIGNMENT_CAST = const StrongModeCode(
+      ErrorType.HINT, 'ASSIGNMENT_CAST', _implicitCastMessage);
+
+  static const StrongModeCode INVALID_PARAMETER_DECLARATION =
+      const StrongModeCode(ErrorType.COMPILE_TIME_ERROR,
+          'INVALID_PARAMETER_DECLARATION', _typeCheckMessage);
+
+  static const StrongModeCode COULD_NOT_INFER = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'COULD_NOT_INFER',
+      "Could not infer type parameter {0}, {1} must be of type {2}.");
+
+  static const StrongModeCode INFERRED_TYPE = const StrongModeCode(
+      ErrorType.HINT, 'INFERRED_TYPE', _inferredTypeMessage);
+
+  static const StrongModeCode INFERRED_TYPE_LITERAL = const StrongModeCode(
+      ErrorType.HINT, 'INFERRED_TYPE_LITERAL', _inferredTypeMessage);
+
+  static const StrongModeCode INFERRED_TYPE_ALLOCATION = const StrongModeCode(
+      ErrorType.HINT, 'INFERRED_TYPE_ALLOCATION', _inferredTypeMessage);
+
+  static const StrongModeCode INFERRED_TYPE_CLOSURE = const StrongModeCode(
+      ErrorType.HINT, 'INFERRED_TYPE_CLOSURE', _inferredTypeMessage);
+
+  static const StrongModeCode STATIC_TYPE_ERROR = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'STATIC_TYPE_ERROR',
+      'Type check failed: {0} ({1}) is not of type {2}');
+
+  static const StrongModeCode INVALID_SUPER_INVOCATION = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'INVALID_SUPER_INVOCATION',
+      "super call must be last in an initializer "
+      "list (see https://goo.gl/EY6hDP): {0}");
+
+  static const StrongModeCode NON_GROUND_TYPE_CHECK_INFO = const StrongModeCode(
+      ErrorType.HINT,
+      'NON_GROUND_TYPE_CHECK_INFO',
+      "Runtime check on non-ground type {0} may throw StrongModeError");
+
+  static const StrongModeCode DYNAMIC_INVOKE = const StrongModeCode(
+      ErrorType.HINT, 'DYNAMIC_INVOKE', '{0} requires a dynamic invoke');
+
+  static const StrongModeCode INVALID_METHOD_OVERRIDE = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'INVALID_METHOD_OVERRIDE',
+      'Invalid override. $_invalidOverrideMessage');
+
+  static const StrongModeCode INVALID_METHOD_OVERRIDE_FROM_BASE =
+      const StrongModeCode(
+          ErrorType.COMPILE_TIME_ERROR,
+          'INVALID_METHOD_OVERRIDE_FROM_BASE',
+          'Base class introduces an invalid override. '
+          '$_invalidOverrideMessage');
+
+  static const StrongModeCode INVALID_METHOD_OVERRIDE_FROM_MIXIN =
+      const StrongModeCode(
+          ErrorType.COMPILE_TIME_ERROR,
+          'INVALID_METHOD_OVERRIDE_FROM_MIXIN',
+          'Mixin introduces an invalid override. $_invalidOverrideMessage');
+
+  static const StrongModeCode INVALID_FIELD_OVERRIDE = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'INVALID_FIELD_OVERRIDE',
+      'Field declaration {3}.{1} cannot be '
+      'overridden in {0}.');
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_PARAMETER = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_PARAMETER',
+      "Missing parameter type for '{0}'$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_RETURN = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_RETURN',
+      "Missing return type for '{0}'$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_VARIABLE = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_VARIABLE',
+      "Missing variable type for '{0}'$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_FIELD = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_FIELD',
+      "Missing field type for '{0}'$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_TYPE = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_TYPE',
+      "Missing type arguments for generic type '{0}'"
+      "$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_LIST_LITERAL =
+      const StrongModeCode(
+          ErrorType.COMPILE_TIME_ERROR,
+          'IMPLICIT_DYNAMIC_LIST_LITERAL',
+          "Missing type argument for list literal$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_MAP_LITERAL =
+      const StrongModeCode(
+          ErrorType.COMPILE_TIME_ERROR,
+          'IMPLICIT_DYNAMIC_MAP_LITERAL',
+          'Missing type arguments for map literal$_implicitDynamicTip');
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_FUNCTION = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_FUNCTION',
+      "Missing type arguments for generic function '{0}<{1}>'"
+      "$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_METHOD = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_METHOD',
+      "Missing type arguments for generic method '{0}<{1}>'"
+      "$_implicitDynamicTip");
+
+  static const StrongModeCode IMPLICIT_DYNAMIC_INVOKE = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_INVOKE',
+      "Missing type arguments for calling generic function type '{0}'"
+      "$_implicitDynamicTip");
+
+  static const StrongModeCode UNSAFE_BLOCK_CLOSURE_INFERENCE =
+      const StrongModeCode(
+          ErrorType.STATIC_WARNING,
+          'UNSAFE_BLOCK_CLOSURE_INFERENCE',
+          _unsafeBlockClosureInferenceMessage);
+
+  @override
+  final ErrorType type;
+
+  /**
+   * Initialize a newly created error code to have the given [type] and [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 optional [correction] template.
+   */
+  const StrongModeCode(ErrorType type, String name, String message,
+      [String correction])
+      : type = type,
+        super('STRONG_MODE_$name', message, correction);
+
+  @override
+  ErrorSeverity get errorSeverity => type.severity;
+}
+
+/**
  * 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');
 
   /**
@@ skipping 16 matching lines @@
    * 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;
 }