Add support for assert statements with messages to the analyzer.

pkg/analyzer/lib/src/generated/error.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.error;
 
 import 'dart:collection';
 
 import 'ast.dart' show AstNode;
 import 'element.dart';
@@ skipping 10 matching lines @@
   /**
    * An empty array of errors used when no errors are expected.
    */
   static const List<AnalysisError> NO_ERRORS = const <AnalysisError>[];
 
   /**
    * A [Comparator] that sorts by the name of the file that the [AnalysisError]
    * was found.
    */
   static Comparator<AnalysisError> FILE_COMPARATOR = (AnalysisError o1,
-      AnalysisError o2) => o1.source.shortName.compareTo(o2.source.shortName);
+          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) {
+  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);
@@ skipping 1504 matching lines @@
    * * 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',
+      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
    */
@@ skipping 15 matching lines @@
           "This class cannot mixin the deferred class '{0}'");
 
   /**
    * Not yet in the spec, but consistent with VM behavior.  It is a
    * compile-time error if all of the constructors of a mixin's base class have
    * at least one optional parameter (since only constructors that lack
    * optional parameters can be forwarded to the mixin).  See
    * https://code.google.com/p/dart/issues/detail?id=15101#c4
    */
   static const CompileTimeErrorCode MIXIN_HAS_NO_CONSTRUCTORS =
-      const CompileTimeErrorCode('MIXIN_HAS_NO_CONSTRUCTORS',
+      const CompileTimeErrorCode(
+          'MIXIN_HAS_NO_CONSTRUCTORS',
           "This mixin application is invalid because all of the constructors "
           "in the base class '{0}' have optional parameters.");
 
   /**
    * 9 Mixins: It is a compile-time error if a mixin is derived from a class
    * whose superclass is not Object.
    *
    * Parameters:
    * 0: the name of the mixin that is invalid
    */
@@ skipping 1268 matching lines @@
 
   /**
    * 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',
+  static const HintCode MISSING_RETURN = const HintCode(
+      'MISSING_RETURN',
       "This function declares a return type of '{0}', but does not end with a return statement",
       "Either add a return statement or change the return type to 'void'");
 
   /**
    * A getter with the override annotation does not override an existing getter.
    */
   static const HintCode OVERRIDE_ON_NON_OVERRIDING_GETTER = const HintCode(
       'OVERRIDE_ON_NON_OVERRIDING_GETTER',
       "Getter does not override an inherited getter");
 
@@ skipping 297 matching lines @@
 }
 
 /**
  * The error codes used for static type warnings. The convention for this class
  * is for the name of the error code to indicate the problem that caused the
  * error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  */
 class StaticTypeWarningCode extends ErrorCode {
   /**
+   * 17.17 Assert:  It is a static type warning if the type of s may not be
+   * assigned to String.
+   */
+  static const StaticTypeWarningCode ASSERT_MESSAGE_NON_STRING =
+      const StaticTypeWarningCode('ASSERT_MESSAGE_NON_STRING',
+          "Assertion messages must be assignable to String");
+
+  /**
    * 12.7 Lists: A fresh instance (7.6.1) <i>a</i>, of size <i>n</i>, whose
    * class implements the built-in class <i>List&lt;E></i> is allocated.
    *
    * Parameters:
    * 0: the number of provided type arguments
    */
   static const StaticTypeWarningCode EXPECTED_ONE_LIST_TYPE_ARGUMENTS =
       const StaticTypeWarningCode('EXPECTED_ONE_LIST_TYPE_ARGUMENTS',
           "List literal requires exactly one type arguments or none, but {0} found");
 
@@ skipping 505 matching lines @@
    * 2. If <i>N</i> is referenced as a function, getter or setter, a
    *    <i>NoSuchMethodError</i> is raised.
    * 3. If <i>N</i> is referenced as a type, it is treated as a malformed type.
    *
    * Parameters:
    * 0: the name of the ambiguous type
    * 1: the name of the first library that the type is found
    * 2: the name of the second library that the type is found
    */
   static const StaticWarningCode AMBIGUOUS_IMPORT = const StaticWarningCode(
-      'AMBIGUOUS_IMPORT', "The name '{0}' is defined in the libraries {1}",
+      'AMBIGUOUS_IMPORT',
+      "The name '{0}' is defined in the libraries {1}",
       "Consider using 'as prefix' for one of the import directives "
       "or hiding the name from all but one of the imports.");
 
   /**
    * 12.11.1 New: It is a static warning if the static type of <i>a<sub>i</sub>,
    * 1 &lt;= i &lt;= n+ k</i> may not be assigned to the type of the
    * corresponding formal parameter of the constructor <i>T.id</i> (respectively
    * <i>T</i>).
    *
    * 12.11.2 Const: It is a static warning if the static type of
@@ skipping 1196 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;
 }