Update analyzer-experimental.

pkg/analyzer-experimental/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 'dart:collection';
+import 'dart:uri';
 import 'package:analyzer-experimental/src/generated/java_core.dart';
 import 'package:analyzer-experimental/src/generated/java_engine.dart';
 import 'package:analyzer-experimental/src/generated/java_junit.dart';
 import 'package:analyzer-experimental/src/generated/source.dart';
 import 'package:analyzer-experimental/src/generated/error.dart';
 import 'package:analyzer-experimental/src/generated/scanner.dart';
+import 'package:analyzer-experimental/src/generated/element.dart' show InterfaceType, MethodElement, PropertyAccessorElement;
 import 'package:unittest/unittest.dart' as _ut;
 
 /**
  * Instances of the class {@code GatheringErrorListener} implement an error listener that collects
  * all of the errors passed to it for later examination.
  */
 class GatheringErrorListener implements AnalysisErrorListener {
   /**
    * The source being parsed.
    */
@@ skipping 12 matching lines @@
    */
   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);
   /**
    * Initialize a newly created error listener to collect errors.
    */
   GatheringErrorListener() : super() {
-    _jtd_constructor_258_impl();
+    _jtd_constructor_297_impl();
   }
-  _jtd_constructor_258_impl() {
+  _jtd_constructor_297_impl() {
   }
   /**
    * Initialize a newly created error listener to collect errors.
    */
   GatheringErrorListener.con1(String rawSource2) {
-    _jtd_constructor_259_impl(rawSource2);
+    _jtd_constructor_298_impl(rawSource2);
   }
-  _jtd_constructor_259_impl(String rawSource2) {
+  _jtd_constructor_298_impl(String rawSource2) {
     this._rawSource = rawSource2;
     this._markedSource = rawSource2;
   }
   /**
    * 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
@@ skipping 47 matching lines @@
       int expectedCount = entry.getValue();
       int actualCount;
       List<AnalysisError> list = errorsByCode.remove(code);
       if (list == null) {
         actualCount = 0;
       } else {
         actualCount = list.length;
       }
       if (actualCount != expectedCount) {
         if (builder.length == 0) {
-          builder.add("Expected ");
+          builder.write("Expected ");
         } else {
-          builder.add("; ");
+          builder.write("; ");
         }
-        builder.add(expectedCount);
-        builder.add(" errors of type ");
-        builder.add(code);
-        builder.add(", found ");
-        builder.add(actualCount);
+        builder.write(expectedCount);
+        builder.write(" errors of type ");
+        builder.write(code);
+        builder.write(", found ");
+        builder.write(actualCount);
       }
     }
     for (MapEntry<ErrorCode, List<AnalysisError>> entry in getMapEntrySet(errorsByCode)) {
       ErrorCode code = entry.getKey();
       List<AnalysisError> actualErrors = entry.getValue();
       int actualCount = actualErrors.length;
       if (builder.length == 0) {
-        builder.add("Expected ");
+        builder.write("Expected ");
       } else {
-        builder.add("; ");
+        builder.write("; ");
       }
-      builder.add("0 errors of type ");
-      builder.add(code);
-      builder.add(", found ");
-      builder.add(actualCount);
-      builder.add(" (");
+      builder.write("0 errors of type ");
+      builder.write(code);
+      builder.write(", found ");
+      builder.write(actualCount);
+      builder.write(" (");
       for (int i = 0; i < actualErrors.length; i++) {
         AnalysisError error = actualErrors[i];
         if (i > 0) {
-          builder.add(", ");
+          builder.write(", ");
         }
-        builder.add(error.offset);
+        builder.write(error.offset);
       }
-      builder.add(")");
+      builder.write(")");
     }
     if (builder.length > 0) {
       JUnitTestCase.fail(builder.toString());
     }
   }
   /**
    * Assert that the number of errors that have been gathered matches the number of severities that
    * are given and that there are the same number of errors and warnings as specified by the
    * argument. The order in which the errors were gathered is ignored.
    * @param expectedSeverities the severities of the errors that should have been gathered
@@ skipping 99 matching lines @@
    * is ignored.
    * @param errorCodes the errors that should have been gathered
    * @throws AssertionFailedError with
    */
   void fail(List<AnalysisError> expectedErrors) {
     PrintStringWriter writer = new PrintStringWriter();
     writer.print("Expected ");
     writer.print(expectedErrors.length);
     writer.print(" errors:");
     for (AnalysisError error in expectedErrors) {
-      Source source9 = error.source;
-      LineInfo lineInfo = _lineInfoMap[source9];
+      Source source11 = error.source;
+      LineInfo lineInfo = _lineInfoMap[source11];
       writer.println();
       if (lineInfo == null) {
-        int offset9 = error.offset;
-        writer.printf("  %s %s (%d..%d)", [source9 == null ? "" : source9.shortName, error.errorCode, offset9, offset9 + error.length]);
+        int offset10 = error.offset;
+        writer.printf("  %s %s (%d..%d)", [source11 == null ? "" : source11.shortName, error.errorCode, offset10, offset10 + error.length]);
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        writer.printf("  %s %s (%d, %d/%d)", [source9 == null ? "" : source9.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length]);
+        writer.printf("  %s %s (%d, %d/%d)", [source11 == null ? "" : source11.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length]);
       }
     }
     writer.println();
     writer.print("found ");
     writer.print(_errors.length);
     writer.print(" errors:");
     for (AnalysisError error in _errors) {
-      Source source10 = error.source;
-      LineInfo lineInfo = _lineInfoMap[source10];
+      Source source12 = error.source;
+      LineInfo lineInfo = _lineInfoMap[source12];
       writer.println();
       if (lineInfo == null) {
-        int offset10 = error.offset;
-        writer.printf("  %s %s (%d..%d): %s", [source10 == null ? "" : source10.shortName, error.errorCode, offset10, offset10 + error.length, error.message]);
+        int offset11 = error.offset;
+        writer.printf("  %s %s (%d..%d): %s", [source12 == null ? "" : source12.shortName, error.errorCode, offset11, offset11 + error.length, error.message]);
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        writer.printf("  %s %s (%d, %d/%d): %s", [source10 == null ? "" : source10.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length, error.message]);
+        writer.printf("  %s %s (%d, %d/%d): %s", [source12 == null ? "" : source12.shortName, error.errorCode, location.lineNumber, location.columnNumber, error.length, error.message]);
       }
     }
     JUnitTestCase.fail(writer.toString());
   }
   /**
    * Search through the given list of errors for an error that is equal to the target error. If one
    * is found, remove it from the list and return {@code true}, otherwise return {@code false}without modifying the list.
    * @param errors the errors through which we are searching
    * @param targetError the error being searched for
    * @return {@code true} if the error is found and removed from the list
@@ skipping 34 matching lines @@
    * Assert that the array of actual values contain exactly the same values as those in the array of
    * expected value, with the exception that the order of the elements is not required to be the
    * same.
    * @param expectedValues the values that are expected to be found
    * @param actualValues the actual values that are being compared against the expected values
    */
   static void assertEqualsIgnoreOrder(List<Object> expectedValues, List<Object> actualValues) {
     JUnitTestCase.assertNotNull(actualValues);
     int expectedLength = expectedValues.length;
     JUnitTestCase.assertEquals(expectedLength, actualValues.length);
-    List<bool> found = new List<bool>(expectedLength);
+    List<bool> found = new List<bool>.filled(expectedLength, false);
     for (int i = 0; i < expectedLength; i++) {
       found[i] = false;
     }
     for (Object actualValue in actualValues) {
       bool wasExpected = false;
       for (int i = 0; i < expectedLength; i++) {
         if (!found[i] && expectedValues[i] == actualValue) {
           found[i] = true;
           wasExpected = true;
           break;
@@ skipping 99 matching lines @@
    * Assert that the given object is an instance of the expected class.
    * @param expectedClass the class that the object is expected to be an instance of
    * @param object the object being tested
    * @return the object that was being tested
    * @throws Exception if the object is not an instance of the expected class
    */
   static Object assertInstanceOf(Type expectedClass, Object object) {
     if (!isInstanceOf(object, expectedClass)) {
       JUnitTestCase.fail("Expected instance of ${expectedClass.toString()}, found ${(object == null ? "null" : object.runtimeType.toString())}");
     }
-    return (object as Object);
+    return object as Object;
   }
   /**
    * Assert that the given array is non-{@code null} and has the expected number of elements.
    * @param expectedLength the expected number of elements
    * @param array the array being tested
    * @throws AssertionFailedError if the array is {@code null} or does not have the expected number
    * of elements
    */
   static void assertLength(int expectedLength, List<Object> array) {
     if (array == null) {
@@ skipping 72 matching lines @@
       if (str1.codeUnitAt(i) != str2.codeUnitAt(i)) {
         diffPos = i;
         break;
       }
     }
     if (diffPos == -1 && str1.length != str2.length) {
       diffPos = len1;
     }
     return diffPos;
   }
+  /**
+   * Return the getter in the given type with the given name. Inherited getters are ignored.
+   * @param type the type in which the getter is declared
+   * @param getterName the name of the getter to be returned
+   * @return the property accessor element representing the getter with the given name
+   */
+  PropertyAccessorElement getGetter(InterfaceType type, String getterName) {
+    for (PropertyAccessorElement accessor in type.element.accessors) {
+      if (accessor.isGetter() && accessor.name == getterName) {
+        return accessor;
+      }
+    }
+    JUnitTestCase.fail("Could not find getter named ${getterName} in ${type.name}");
+    return null;
+  }
+  /**
+   * Return the method in the given type with the given name. Inherited methods are ignored.
+   * @param type the type in which the method is declared
+   * @param methodName the name of the method to be returned
+   * @return the method element representing the method with the given name
+   */
+  MethodElement getMethod(InterfaceType type, String methodName) {
+    for (MethodElement method in type.element.methods) {
+      if (method.name == methodName) {
+        return method;
+      }
+    }
+    JUnitTestCase.fail("Could not find method named ${methodName} in ${type.name}");
+    return null;
+  }
   static dartSuite() {
     _ut.group('EngineTestCase', () {
     });
   }
 }
 main() {
 }
 
 class TestSource implements Source {
   bool operator ==(Object object) {
     return this == object;
   }
   void getContents(Source_ContentReceiver receiver) {
     throw new UnsupportedOperationException();
   }
   String get fullName {
     throw new UnsupportedOperationException();
   }
   String get shortName {
     throw new UnsupportedOperationException();
   }
+  String get encoding {
+    throw new UnsupportedOperationException();
+  }
+  bool exists() => true;
   bool isInSystemLibrary() {
     throw new UnsupportedOperationException();
   }
   Source resolve(String uri) {
     throw new UnsupportedOperationException();
   }
+  Source resolveRelative(Uri uri) {
+    throw new UnsupportedOperationException();
+  }
 }
 
 /**
  * Wrapper around [Function] which should be called with [target] and [arguments].
  */
 class MethodTrampoline {
   int parameterCount;
   Function trampoline;
   MethodTrampoline(this.parameterCount, this.trampoline);
   Object invoke(target, List arguments) {
     if (arguments.length != parameterCount) {
       throw new IllegalArgumentException("${arguments.length} != $parameterCount");
     }
     switch (parameterCount) {
       case 0:
         return trampoline(target);
       case 1:
         return trampoline(target, arguments[0]);
       case 2:
         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");
     }
   }
 }