Use limited JavaStringBuilder implementation instead of Dart StringBuffer.

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';
@@ skipping 71 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. The order in which the errors were gathered
    * is ignored.
    * @param expectedErrorCodes the error codes of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    * expected
    */
   void assertErrors2(List<ErrorCode> expectedErrorCodes) {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     Map<ErrorCode, int> expectedCounts = new Map<ErrorCode, int>();
     for (ErrorCode code in expectedErrorCodes) {
       int count = expectedCounts[code];
       if (count == null) {
         count = 1;
       } else {
         count = count + 1;
       }
       expectedCounts[code] = count;
     }
@@ skipping 12 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.write("Expected ");
+          builder.append("Expected ");
         } else {
-          builder.write("; ");
+          builder.append("; ");
         }
-        builder.write(expectedCount);
-        builder.write(" errors of type ");
-        builder.write(code);
-        builder.write(", found ");
-        builder.write(actualCount);
+        builder.append(expectedCount);
+        builder.append(" errors of type ");
+        builder.append(code);
+        builder.append(", found ");
+        builder.append(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.write("Expected ");
+        builder.append("Expected ");
       } else {
-        builder.write("; ");
+        builder.append("; ");
       }
-      builder.write("0 errors of type ");
-      builder.write(code);
-      builder.write(", found ");
-      builder.write(actualCount);
-      builder.write(" (");
+      builder.append("0 errors of type ");
+      builder.append(code);
+      builder.append(", found ");
+      builder.append(actualCount);
+      builder.append(" (");
       for (int i = 0; i < actualErrors.length; i++) {
         AnalysisError error = actualErrors[i];
         if (i > 0) {
-          builder.write(", ");
+          builder.append(", ");
         }
-        builder.write(error.offset);
+        builder.append(error.offset);
       }
-      builder.write(")");
+      builder.append(")");
     }
     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 484 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");
     }
   }
 }