Improve strong-mode implementation and fix several failing tests

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 736 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].
  */
@@ skipping 512 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 822 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;
 }