Use limited JavaStringBuilder implementation instead of Dart StringBuffer.

pkg/analyzer-experimental/lib/src/generated/ast.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.ast;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'error.dart';
 import 'source.dart' show LineInfo;
@@ skipping 6780 matching lines @@
   accept(ASTVisitor visitor) => visitor.visitLibraryIdentifier(this);
   Token get beginToken => _components.beginToken;
   /**
    * Return the components of the identifier.
    * @return the components of the identifier
    */
   NodeList<SimpleIdentifier> get components => _components;
   Element get element => null;
   Token get endToken => _components.endToken;
   String get name {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     bool needsPeriod = false;
     for (SimpleIdentifier identifier in _components) {
       if (needsPeriod) {
-        builder.write(".");
+        builder.append(".");
       } else {
         needsPeriod = true;
       }
-      builder.write(identifier.name);
+      builder.append(identifier.name);
     }
     return builder.toString();
   }
   void visitChildren(ASTVisitor<Object> visitor) {
     _components.accept(visitor);
   }
 }
 /**
  * Instances of the class {@code ListLiteral} represent a list literal.
  * <pre>
@@ skipping 4022 matching lines @@
  * conditions encountered during evaluation. These are documented with the static field that define
  * those values.
  */
 class ConstantEvaluator extends GeneralizingASTVisitor<Object> {
   /**
    * The value returned for expressions (or non-expression nodes) that are not compile-time constant
    * expressions.
    */
   static Object NOT_A_CONSTANT = new Object();
   Object visitAdjacentStrings(AdjacentStrings node) {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
-      builder.write(value);
+      builder.append(value);
     }
     return builder.toString();
   }
   Object visitBinaryExpression(BinaryExpression node) {
     Object leftOperand2 = node.leftOperand.accept(this);
     if (identical(leftOperand2, NOT_A_CONSTANT)) {
       return leftOperand2;
     }
     Object rightOperand2 = node.rightOperand.accept(this);
     if (identical(rightOperand2, NOT_A_CONSTANT)) {
@@ skipping 178 matching lines @@
         }
       }
       break;
     }
     return NOT_A_CONSTANT;
   }
   Object visitPropertyAccess(PropertyAccess node) => getConstantValue(null);
   Object visitSimpleIdentifier(SimpleIdentifier node) => getConstantValue(null);
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => node.value;
   Object visitStringInterpolation(StringInterpolation node) {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     for (InterpolationElement element in node.elements) {
       Object value = element.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
-      builder.write(value);
+      builder.append(value);
     }
     return builder.toString();
   }
   /**
    * Return the constant value of the static constant represented by the given element.
    * @param element the element whose value is to be returned
    * @return the constant value of the static constant
    */
   Object getConstantValue(Element element) {
     if (element is FieldElement) {
@@ skipping 1647 matching lines @@
     return elements[elements.length - 1].endToken;
   }
   /**
    * Return the node that is the parent of each of the elements in the list.
    * @return the node that is the parent of each of the elements in the list
    */
   ASTNode getOwner() {
     return owner;
   }
 }