Roll Observatory packages and add a roll script

packages/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;
-    ErrorType errorType1 = errorCode1.type;
-    ErrorType errorType2 = errorCode2.type;
     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;
@@ skipping 17 matching lines @@
   /**
    * 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;
+  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, int length, this.errorCode,
+  AnalysisError(this.source, this.offset, this.length, this.errorCode,
       [List<Object> arguments]) {
-    this._length = length;
     this._message = formatList(errorCode.message, arguments);
     String correctionTemplate = errorCode.correction;
     if (correctionTemplate != null) {
       this._correction = formatList(correctionTemplate, arguments);
     }
   }
 
   /**
    * Initialize a newly created analysis error for the specified [source]. The
    * error will have the given [errorCode] and the list of [arguments] will be
@@ skipping 24 matching lines @@
 
   @override
   int get hashCode {
     int hashCode = offset;
     hashCode ^= (_message != null) ? _message.hashCode : 0;
     hashCode ^= (source != null) ? source.hashCode : 0;
     return hashCode;
   }
 
   /**
-   * Return the length of the error location, that is, the number of characters
-   * from the offset to the end of the source which encompasses the compilation
-   * error.
-   */
-  int get length => _length;
-
-  /**
    * Return the message to be displayed for this error. The message should
    * indicate what is wrong and why it is wrong.
    */
   String get message => _message;
 
   @override
   bool operator ==(Object obj) {
     if (identical(obj, this)) {
       return true;
     }
     // prepare other AnalysisError
     if (obj is! AnalysisError) {
       return false;
     }
     AnalysisError other = obj as AnalysisError;
     // Quick checks.
     if (!identical(errorCode, other.errorCode)) {
       return false;
     }
-    if (offset != other.offset || _length != other._length) {
+    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(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.
    */
@@ skipping 391 matching lines @@
       const CompileTimeErrorCode('CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD',
           "'{0}' cannot be used to name a constructor and a method in this class");
 
   /**
    * 7. Classes: It is a compile time error if a generic class declares a type
    * variable with the same name as the class or any of its members or
    * constructors.
    */
   static const CompileTimeErrorCode CONFLICTING_TYPE_VARIABLE_AND_CLASS =
       const CompileTimeErrorCode('CONFLICTING_TYPE_VARIABLE_AND_CLASS',
-          "'{0}' cannot be used to name a type varaible in a class with the same name");
+          "'{0}' cannot be used to name a type variable in a class with the same name");
 
   /**
    * 7. Classes: It is a compile time error if a generic class declares a type
    * variable with the same name as the class or any of its members or
    * constructors.
    */
   static const CompileTimeErrorCode CONFLICTING_TYPE_VARIABLE_AND_MEMBER =
       const CompileTimeErrorCode('CONFLICTING_TYPE_VARIABLE_AND_MEMBER',
-          "'{0}' cannot be used to name a type varaible and member in this class");
+          "'{0}' cannot be used to name a type variable and member in this class");
 
   /**
    * 12.11.2 Const: It is a compile-time error if evaluation of a constant
    * object results in an uncaught exception being thrown.
    */
   static const CompileTimeErrorCode CONST_CONSTRUCTOR_THROWS_EXCEPTION =
       const CompileTimeErrorCode('CONST_CONSTRUCTOR_THROWS_EXCEPTION',
           "'const' constructors cannot throw exceptions");
 
   /**
@@ skipping 929 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 137 matching lines @@
    * Report the given [error].
    */
   void reportError(AnalysisError error) {
     _errorListener.onError(error);
   }
 
   /**
    * Report an error with the given [errorCode] and [arguments]. The [element]
    * is used to compute the location of the error.
    */
-  void reportErrorForElement(
-      ErrorCode errorCode, Element element, List<Object> arguments) {
-    String displayName = element.displayName;
+  void reportErrorForElement(ErrorCode errorCode, Element element,
+      [List<Object> arguments]) {
     int length = 0;
-    if (displayName != null) {
-      length = displayName.length;
-    } else if (element is ImportElement) {
+    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
@@ skipping 345 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 131 matching lines @@
       "The exception variable '{0}' is not used, so the 'catch' clause can be removed");
 
   /**
    * Unused catch stack trace variables.
    */
   static const HintCode UNUSED_CATCH_STACK = const HintCode(
       'UNUSED_CATCH_STACK',
       "The stack trace variable '{0}' is not used and can be removed");
 
   /**
-   * Unused local variables are local varaibles which are never read.
+   * 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");
 
   /**
    * 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:
@@ skipping 670 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 203 matching lines @@
    * Parameters:
    * 0: the uri pointing to a first library
    * 1: the uri pointing to a second library
    * 2:e the shared name of the exported libraries
    */
   static const StaticWarningCode EXPORT_DUPLICATED_LIBRARY_NAMED =
       const StaticWarningCode('EXPORT_DUPLICATED_LIBRARY_NAMED',
           "The exported libraries '{0}' and '{1}' cannot have the same name '{2}'");
 
   /**
-   * 14.2 Exports: It is a static warning to export two different libraries with
-   * the same name.
-   *
-   * Parameters:
-   * 0: the uri pointing to a first library
-   * 1: the uri pointing to a second library
-   */
-  static const StaticWarningCode EXPORT_DUPLICATED_LIBRARY_UNNAMED =
-      const StaticWarningCode('EXPORT_DUPLICATED_LIBRARY_UNNAMED',
-          "The exported libraries '{0}' and '{1}' cannot both be unnamed");
-
-  /**
    * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt;
    * h</i> or if <i>m &gt; n</i>.
    *
    * Parameters:
    * 0: the maximum number of positional arguments
    * 1: the actual number of positional arguments given
    *
    * See [NOT_ENOUGH_REQUIRED_ARGUMENTS].
    */
   static const StaticWarningCode EXTRA_POSITIONAL_ARGUMENTS =
@@ skipping 135 matching lines @@
    * Parameters:
    * 0: the uri pointing to a first library
    * 1: the uri pointing to a second library
    * 2: the shared name of the imported libraries
    */
   static const StaticWarningCode IMPORT_DUPLICATED_LIBRARY_NAMED =
       const StaticWarningCode('IMPORT_DUPLICATED_LIBRARY_NAMED',
           "The imported libraries '{0}' and '{1}' cannot have the same name '{2}'");
 
   /**
-   * 14.1 Imports: It is a static warning to import two different libraries with
-   * the same name.
-   *
-   * Parameters:
-   * 0: the uri pointing to a first library
-   * 1: the uri pointing to a second library
-   */
-  static const StaticWarningCode IMPORT_DUPLICATED_LIBRARY_UNNAMED =
-      const StaticWarningCode('IMPORT_DUPLICATED_LIBRARY_UNNAMED',
-          "The imported libraries '{0}' and '{1}' cannot both be unnamed");
-
-  /**
    * 14.1 Imports: It is a static warning if the specified URI of a deferred
    * import does not refer to a library declaration.
    *
    * Parameters:
    * 0: the uri pointing to a non-library declaration
    *
    * See [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY].
    */
   static const StaticWarningCode IMPORT_OF_NON_LIBRARY =
       const StaticWarningCode('IMPORT_OF_NON_LIBRARY',
@@ skipping 818 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;
 }