New analyzer snapshot.

pkg/analyzer/test/generated/test_support.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.test_support;
 
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
@@ skipping 14 matching lines @@
 
   /**
    * The source being parsed after inserting a marker at the beginning and end of the range of the
    * most recent error.
    */
   String _markedSource;
 
   /**
    * A list containing the errors that were collected.
    */
-  final List<AnalysisError> errors = new List<AnalysisError>();
+  List<AnalysisError> _errors = new List<AnalysisError>();
 
   /**
    * A table mapping sources to the line information for the source.
    */
   Map<Source, LineInfo> _lineInfoMap = new Map<Source, LineInfo>();
 
   /**
    * An empty array of errors used when no errors are expected.
    */
   static List<AnalysisError> _NO_ERRORS = new List<AnalysisError>(0);
@@ skipping 25 matching lines @@
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes and locations. The order in which the errors
    * were gathered is ignored.
    *
    * @param errorCodes the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    *           expected or if they do not have the same codes and locations
    */
   void assertErrors(List<AnalysisError> expectedErrors) {
-    if (errors.length != expectedErrors.length) {
+    if (_errors.length != expectedErrors.length) {
       fail(expectedErrors);
     }
     List<AnalysisError> remainingErrors = new List<AnalysisError>();
     for (AnalysisError error in expectedErrors) {
       remainingErrors.add(error);
     }
-    for (AnalysisError error in errors) {
+    for (AnalysisError error in _errors) {
       if (!foundAndRemoved(remainingErrors, error)) {
         fail(expectedErrors);
       }
     }
   }
 
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes. The order in which the errors were gathered
    * is ignored.
@@ skipping 11 matching lines @@
     for (ErrorCode code in expectedErrorCodes) {
       int count = expectedCounts[code];
       if (count == null) {
         count = 1;
       } else {
         count = count + 1;
       }
       expectedCounts[code] = count;
     }
     Map<ErrorCode, List<AnalysisError>> errorsByCode = new Map<ErrorCode, List<AnalysisError>>();
-    for (AnalysisError error in errors) {
+    for (AnalysisError error in _errors) {
       ErrorCode code = error.errorCode;
       List<AnalysisError> list = errorsByCode[code];
       if (list == null) {
         list = new List<AnalysisError>();
         errorsByCode[code] = list;
       }
       list.add(error);
     }
     for (MapEntry<ErrorCode, int> entry in getMapEntrySet(expectedCounts)) {
       ErrorCode code = entry.getKey();
@@ skipping 60 matching lines @@
     int expectedWarningCount = 0;
     for (ErrorSeverity severity in expectedSeverities) {
       if (identical(severity, ErrorSeverity.ERROR)) {
         expectedErrorCount++;
       } else {
         expectedWarningCount++;
       }
     }
     int actualErrorCount = 0;
     int actualWarningCount = 0;
-    for (AnalysisError error in errors) {
+    for (AnalysisError error in _errors) {
       if (identical(error.errorCode.errorSeverity, ErrorSeverity.ERROR)) {
         actualErrorCount++;
       } else {
         actualWarningCount++;
       }
     }
     if (expectedErrorCount != actualErrorCount || expectedWarningCount != actualWarningCount) {
       JUnitTestCase.fail("Expected ${expectedErrorCount} errors and ${expectedWarningCount} warnings, found ${actualErrorCount} errors and ${actualWarningCount} warnings");
     }
   }
 
   /**
    * Assert that no errors have been gathered.
    *
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
     assertErrors(_NO_ERRORS);
   }
 
   /**
+   * Return the errors that were collected.
+   *
+   * @return the errors that were collected
+   */
+  List<AnalysisError> get errors => _errors;
+
+  /**
    * Return the line information associated with the given source, or `null` if no line
    * information has been associated with the source.
    *
    * @param source the source with which the line information is associated
    * @return the line information associated with the source
    */
   LineInfo getLineInfo(Source source) => _lineInfoMap[source];
 
   /**
    * Return `true` if an error with the given error code has been gathered.
    *
    * @param errorCode the error code being searched for
    * @return `true` if an error with the given error code has been gathered
    */
   bool hasError(ErrorCode errorCode) {
-    for (AnalysisError error in errors) {
+    for (AnalysisError error in _errors) {
       if (identical(error.errorCode, errorCode)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if at least one error has been gathered.
    *
    * @return `true` if at least one error has been gathered
    */
-  bool hasErrors() => errors.length > 0;
+  bool hasErrors() => _errors.length > 0;
 
   void onError(AnalysisError error) {
     if (_rawSource != null) {
       int left = error.offset;
       int right = left + error.length - 1;
       _markedSource = "${_rawSource.substring(0, left)}^${_rawSource.substring(left, right)}^${_rawSource.substring(right)}";
     }
-    errors.add(error);
+    _errors.add(error);
   }
 
   /**
    * Set the line information associated with the given source to the given information.
    *
    * @param source the source with which the line information is associated
    * @param lineStarts the line start information to be associated with the source
    */
   void setLineInfo(Source source, List<int> lineStarts) {
     _lineInfoMap[source] = new LineInfo(lineStarts);
@@ skipping 63 matching lines @@
         writer.printf("  %s %s (%d, %d/%d)", [
             source == null ? "" : source.shortName,
             error.errorCode,
             location.lineNumber,
             location.columnNumber,
             error.length]);
       }
     }
     writer.newLine();
     writer.print("found ");
-    writer.print(errors.length);
+    writer.print(_errors.length);
     writer.print(" errors:");
-    for (AnalysisError error in errors) {
+    for (AnalysisError error in _errors) {
       Source source = error.source;
       LineInfo lineInfo = _lineInfoMap[source];
       writer.newLine();
       if (lineInfo == null) {
         int offset = error.offset;
         writer.printf("  %s %s (%d..%d): %s", [
             source == null ? "" : source.shortName,
             error.errorCode,
             offset,
             offset + error.length,
@@ skipping 503 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }