Remove JavaStringBuilder

pkg/analyzer/lib/src/generated/element.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.
 
 // 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.element;
 
 import 'dart:collection';
@@ skipping 366 matching lines @@
           if (className == name) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(".");
-    builder.append(name);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(".");
+    buffer.write(name);
   }
 }
 
 /**
  * The interface `AngularElement` defines the behavior of objects representing information
  * about an Angular element which is applied conditionally using some [AngularSelectorElement].
  */
 abstract class AngularHasSelectorElement implements AngularElement {
   /**
    * Returns the selector specified for this element.
@@ skipping 1237 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
     safelyVisitChildren(_toolkitObjects, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     String name = displayName;
     if (name == null) {
-      builder.append("{unnamed class}");
+      buffer.write("{unnamed class}");
     } else {
-      builder.append(name);
+      buffer.write(name);
     }
     int variableCount = _typeParameters.length;
     if (variableCount > 0) {
-      builder.append("<");
+      buffer.write("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
-          builder.append(", ");
+          buffer.write(", ");
         }
-        (_typeParameters[i] as TypeParameterElementImpl).appendTo(builder);
+        (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
       }
-      builder.append(">");
+      buffer.write(">");
     }
   }
 
   void _collectAllSupertypes(List<InterfaceType> supertypes) {
     List<InterfaceType> typesToVisit = new List<InterfaceType>();
     List<ClassElement> visitedClasses = new List<ClassElement>();
     typesToVisit.add(this.type);
     while (!typesToVisit.isEmpty) {
       InterfaceType currentType = typesToVisit.removeAt(0);
       ClassElement currentElement = currentType.element;
@@ skipping 559 matching lines @@
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
     safelyVisitChildren(_angularViews, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     if (source == null) {
-      builder.append("{compilation unit}");
+      buffer.write("{compilation unit}");
     } else {
-      builder.append(source.fullName);
+      buffer.write(source.fullName);
     }
   }
 
   @override
   String get identifier => source.encoding;
 
   /**
    * Returns the associated toolkit objects.
    *
    * @param element the [Element] to get toolkit objects for
@@ skipping 240 matching lines @@
   /**
    * Set whether this constructor represents a factory method to the given value.
    *
    * @param isFactory `true` if this constructor represents a factory method
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(enclosingElement.displayName);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
-      builder.append(".");
-      builder.append(name);
+      buffer.write(".");
+      buffer.write(name);
     }
-    super.appendTo(builder);
+    super.appendTo(buffer);
   }
 }
 
 /**
  * Instances of the class `ConstructorMember` represent a constructor element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ConstructorMember extends ExecutableMember implements ConstructorElement {
   /**
    * If the given constructor's type is different when any type parameters from the defining type's
@@ skipping 56 matching lines @@
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
 
   @override
   bool get isFactory => baseElement.isFactory;
 
   @override
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append(baseElement.enclosingElement.displayName);
+    StringBuffer buffer = new StringBuffer();
+    buffer.write(baseElement.enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
-      builder.append(".");
-      builder.append(name);
+      buffer.write(".");
+      buffer.write(name);
     }
-    builder.append("(");
+    buffer.write("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.append(", ");
+        buffer.write(", ");
       }
-      builder.append(parameters[i]).toString();
+      buffer.write(parameters[i]);
     }
-    builder.append(")");
+    buffer.write(")");
     if (type != null) {
-      builder.append(Element.RIGHT_ARROW);
-      builder.append(type.returnType);
+      buffer.write(Element.RIGHT_ARROW);
+      buffer.write(type.returnType);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 
   @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The interface `Type` defines the behavior of objects representing the declared type of
  * elements in the element model.
  */
@@ skipping 852 matching lines @@
    * Set whether this element is synthetic to correspond to the given value.
    *
    * @param isSynthetic `true` if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
 
   @override
   String toString() {
-    JavaStringBuilder builder = new JavaStringBuilder();
-    appendTo(builder);
-    return builder.toString();
+    StringBuffer buffer = new StringBuffer();
+    appendTo(buffer);
+    return buffer.toString();
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     // There are no children to visit
   }
 
   /**
-   * Append a textual representation of this type to the given builder.
-   *
-   * @param builder the builder to which the text is to be appended
+   * Append a textual representation of this element to the given [buffer].
    */
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     if (_name == null) {
-      builder.append("<unnamed ");
-      builder.append(runtimeType.toString());
-      builder.append(">");
+      buffer.write("<unnamed ");
+      buffer.write(runtimeType.toString());
+      buffer.write(">");
     } else {
-      builder.append(_name);
+      buffer.write(_name);
     }
   }
 
   /**
    * Set this [Element] as an enclosing for given.
    *
    * @param element the element to enclose, must be [ElementImpl]
    */
   void encloseElement(ElementImpl element) {
     element.enclosingElement = this;
@@ skipping 299 matching lines @@
       }
     }
     return true;
   }
 
   @override
   List<String> get components => _components;
 
   @override
   String get encoding {
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     int length = _components.length;
     for (int i = 0; i < length; i++) {
       if (i > 0) {
-        builder.appendChar(_SEPARATOR_CHAR);
+        buffer.writeCharCode(_SEPARATOR_CHAR);
       }
-      _encode(builder, _components[i]);
+      _encode(buffer, _components[i]);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 
   @override
   int get hashCode {
     int result = 1;
     for (int i = 0; i < _components.length; i++) {
       String component = _components[i];
       result = 31 * result + component.hashCode;
     }
     return result;
   }
 
   @override
   String toString() => encoding;
 
   /**
    * Decode the encoded form of a location into an array of components.
    *
    * @param encoding the encoded form of a location
    * @return the components that were encoded
    */
   List<String> _decode(String encoding) {
     List<String> components = new List<String>();
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     int index = 0;
     int length = encoding.length;
     while (index < length) {
       int currentChar = encoding.codeUnitAt(index);
       if (currentChar == _SEPARATOR_CHAR) {
         if (index + 1 < length && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
-          builder.appendChar(_SEPARATOR_CHAR);
+          buffer.writeCharCode(_SEPARATOR_CHAR);
           index += 2;
         } else {
-          components.add(builder.toString());
-          builder.length = 0;
+          components.add(buffer.toString());
+          buffer = new StringBuffer();
           index++;
         }
       } else {
-        builder.appendChar(currentChar);
+        buffer.writeCharCode(currentChar);
         index++;
       }
     }
-    components.add(builder.toString());
+    components.add(buffer.toString());
     return new List.from(components);
   }
 
   /**
    * Append an encoded form of the given component to the given builder.
    *
    * @param builder the builder to which the encoded component is to be appended
    * @param component the component to be appended to the builder
    */
-  void _encode(JavaStringBuilder builder, String component) {
+  void _encode(StringBuffer buffer, String component) {
     int length = component.length;
     for (int i = 0; i < length; i++) {
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
-        builder.appendChar(_SEPARATOR_CHAR);
+        buffer.writeCharCode(_SEPARATOR_CHAR);
       }
-      builder.appendChar(currentChar);
+      buffer.writeCharCode(currentChar);
     }
   }
 }
 
 /**
  * The class `ElementPair` is a pair of [Element]s. [Object#equals] and
  * [Object#hashCode] so this class can be used in hashed data structures.
  */
 class ElementPair {
   /**
@@ skipping 431 matching lines @@
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_labels, visitor);
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     if (this.kind != ElementKind.GETTER) {
-      builder.append("(");
+      buffer.write("(");
       String closing = null;
       ParameterKind kind = ParameterKind.REQUIRED;
       int parameterCount = _parameters.length;
       for (int i = 0; i < parameterCount; i++) {
         if (i > 0) {
-          builder.append(", ");
+          buffer.write(", ");
         }
         ParameterElementImpl parameter = _parameters[i] as ParameterElementImpl;
         ParameterKind parameterKind = parameter.parameterKind;
         if (parameterKind != kind) {
           if (closing != null) {
-            builder.append(closing);
+            buffer.write(closing);
           }
           if (parameterKind == ParameterKind.POSITIONAL) {
-            builder.append("[");
+            buffer.write("[");
             closing = "]";
           } else if (parameterKind == ParameterKind.NAMED) {
-            builder.append("{");
+            buffer.write("{");
             closing = "}";
           } else {
             closing = null;
           }
         }
         kind = parameterKind;
-        parameter.appendToWithoutDelimiters(builder);
+        parameter.appendToWithoutDelimiters(buffer);
       }
       if (closing != null) {
-        builder.append(closing);
+        buffer.write(closing);
       }
-      builder.append(")");
+      buffer.write(")");
     }
     if (type != null) {
-      builder.append(Element.RIGHT_ARROW);
-      builder.append(type.returnType);
+      buffer.write(Element.RIGHT_ARROW);
+      buffer.write(type.returnType);
     }
   }
 }
 
 /**
  * The abstract class `ExecutableMember` defines the behavior common to members that represent
  * an executable element defined in a parameterized type where the values of the type parameters are
  * known.
  */
 abstract class ExecutableMember extends Member implements ExecutableElement {
@@ skipping 123 matching lines @@
    */
   ExportElementImpl() : super(null, -1);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
   @override
   ElementKind get kind => ElementKind.EXPORT;
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append("export ");
-    (exportedLibrary as LibraryElementImpl).appendTo(builder);
+  void appendTo(StringBuffer buffer) {
+    buffer.write("export ");
+    (exportedLibrary as LibraryElementImpl).appendTo(buffer);
   }
 
   @override
   String get identifier => exportedLibrary.name;
 }
 
 /**
  * The interface `ExternalHtmlScriptElement` defines the behavior of elements representing a
  * script tag in an HTML file having a `source` attribute that references a Dart library
  * source file.
@@ skipping 232 matching lines @@
   @override
   DartType get propagatedType => substituteFor(baseElement.propagatedType);
 
   @override
   PropertyAccessorElement get setter => PropertyAccessorMember.from(baseElement.setter, definingType);
 
   @override
   bool get isStatic => baseElement.isStatic;
 
   @override
-  String toString() {
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append(type);
-    builder.append(" ");
-    builder.append(displayName);
-    return builder.toString();
-  }
+  String toString() => '$type $displayName';
 
   @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The interface `FunctionElement` defines the behavior of elements representing a function.
  */
 abstract class FunctionElement implements ExecutableElement, LocalElement {
   /**
@@ skipping 98 matching lines @@
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     String name = displayName;
     if (name != null) {
-      builder.append(name);
+      buffer.write(name);
     }
-    super.appendTo(builder);
+    super.appendTo(buffer);
   }
 
   @override
   String get identifier {
     String identifier = super.identifier;
     if (!isStatic) {
       identifier += "@${nameOffset}";
     }
     return identifier;
   }
@@ skipping 307 matching lines @@
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append("typedef ");
-    builder.append(displayName);
+  void appendTo(StringBuffer buffer) {
+    buffer.write("typedef ");
+    buffer.write(displayName);
     int typeParameterCount = _typeParameters.length;
     if (typeParameterCount > 0) {
-      builder.append("<");
+      buffer.write("<");
       for (int i = 0; i < typeParameterCount; i++) {
         if (i > 0) {
-          builder.append(", ");
+          buffer.write(", ");
         }
-        (_typeParameters[i] as TypeParameterElementImpl).appendTo(builder);
+        (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
       }
-      builder.append(">");
+      buffer.write(">");
     }
-    builder.append("(");
+    buffer.write("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.append(", ");
+        buffer.write(", ");
       }
-      (_parameters[i] as ParameterElementImpl).appendTo(builder);
+      (_parameters[i] as ParameterElementImpl).appendTo(buffer);
     }
-    builder.append(")");
+    buffer.write(")");
     if (type != null) {
-      builder.append(Element.RIGHT_ARROW);
-      builder.append(type.returnType);
+      buffer.write(Element.RIGHT_ARROW);
+      buffer.write(type.returnType);
     }
   }
 }
 
 /**
  * Instances of the class `FunctionTypeImpl` defines the behavior common to objects
  * representing the type of a function, method, constructor, getter, or setter.
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
@@ skipping 50 matching lines @@
   @override
   String get displayName {
     String name = this.name;
     if (name == null || name.length == 0) {
       // Function types have an empty name when they are defined implicitly by either a closure or
       // as part of a parameter declaration.
       List<DartType> normalParameterTypes = this.normalParameterTypes;
       List<DartType> optionalParameterTypes = this.optionalParameterTypes;
       Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
       DartType returnType = this.returnType;
-      JavaStringBuilder builder = new JavaStringBuilder();
-      builder.append("(");
+      StringBuffer buffer = new StringBuffer();
+      buffer.write("(");
       bool needsComma = false;
       if (normalParameterTypes.length > 0) {
         for (DartType type in normalParameterTypes) {
           if (needsComma) {
-            builder.append(", ");
+            buffer.write(", ");
           } else {
             needsComma = true;
           }
-          builder.append(type.displayName);
+          buffer.write(type.displayName);
         }
       }
       if (optionalParameterTypes.length > 0) {
         if (needsComma) {
-          builder.append(", ");
+          buffer.write(", ");
           needsComma = false;
         }
-        builder.append("[");
+        buffer.write("[");
         for (DartType type in optionalParameterTypes) {
           if (needsComma) {
-            builder.append(", ");
+            buffer.write(", ");
           } else {
             needsComma = true;
           }
-          builder.append(type.displayName);
+          buffer.write(type.displayName);
         }
-        builder.append("]");
+        buffer.write("]");
         needsComma = true;
       }
       if (namedParameterTypes.length > 0) {
         if (needsComma) {
-          builder.append(", ");
+          buffer.write(", ");
           needsComma = false;
         }
-        builder.append("{");
+        buffer.write("{");
         for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
           if (needsComma) {
-            builder.append(", ");
+            buffer.write(", ");
           } else {
             needsComma = true;
           }
-          builder.append(entry.getKey());
-          builder.append(": ");
-          builder.append(entry.getValue().displayName);
+          buffer.write(entry.getKey());
+          buffer.write(": ");
+          buffer.write(entry.getValue().displayName);
         }
-        builder.append("}");
+        buffer.write("}");
         needsComma = true;
       }
-      builder.append(")");
-      builder.append(Element.RIGHT_ARROW);
+      buffer.write(")");
+      buffer.write(Element.RIGHT_ARROW);
       if (returnType == null) {
-        builder.append("null");
+        buffer.write("null");
       } else {
-        builder.append(returnType.displayName);
+        buffer.write(returnType.displayName);
       }
-      name = builder.toString();
+      name = buffer.toString();
     }
     return name;
   }
 
   @override
   Map<String, DartType> get namedParameterTypes {
     LinkedHashMap<String, DartType> namedParameterTypes = new LinkedHashMap<String, DartType>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
@@ skipping 247 matching lines @@
     if (argumentTypes.length == 0) {
       return this;
     }
     Element element = this.element;
     FunctionTypeImpl newType = (element is ExecutableElement) ? new FunctionTypeImpl.con1(element) : new FunctionTypeImpl.con2(element as FunctionTypeAliasElement);
     newType.typeArguments = TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     return newType;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
     DartType returnType = this.returnType;
-    builder.append("(");
+    buffer.write("(");
     bool needsComma = false;
     if (normalParameterTypes.length > 0) {
       for (DartType type in normalParameterTypes) {
         if (needsComma) {
-          builder.append(", ");
+          buffer.write(", ");
         } else {
           needsComma = true;
         }
-        (type as TypeImpl).appendTo(builder);
+        (type as TypeImpl).appendTo(buffer);
       }
     }
     if (optionalParameterTypes.length > 0) {
       if (needsComma) {
-        builder.append(", ");
+        buffer.write(", ");
         needsComma = false;
       }
-      builder.append("[");
+      buffer.write("[");
       for (DartType type in optionalParameterTypes) {
         if (needsComma) {
-          builder.append(", ");
+          buffer.write(", ");
         } else {
           needsComma = true;
         }
-        (type as TypeImpl).appendTo(builder);
+        (type as TypeImpl).appendTo(buffer);
       }
-      builder.append("]");
+      buffer.write("]");
       needsComma = true;
     }
     if (namedParameterTypes.length > 0) {
       if (needsComma) {
-        builder.append(", ");
+        buffer.write(", ");
         needsComma = false;
       }
-      builder.append("{");
+      buffer.write("{");
       for (MapEntry<String, DartType> entry in getMapEntrySet(namedParameterTypes)) {
         if (needsComma) {
-          builder.append(", ");
+          buffer.write(", ");
         } else {
           needsComma = true;
         }
-        builder.append(entry.getKey());
-        builder.append(": ");
-        (entry.getValue() as TypeImpl).appendTo(builder);
+        buffer.write(entry.getKey());
+        buffer.write(": ");
+        (entry.getValue() as TypeImpl).appendTo(buffer);
       }
-      builder.append("}");
+      buffer.write("}");
       needsComma = true;
     }
-    builder.append(")");
-    builder.append(Element.RIGHT_ARROW);
+    buffer.write(")");
+    buffer.write(Element.RIGHT_ARROW);
     if (returnType == null) {
-      builder.append("null");
+      buffer.write("null");
     } else {
-      (returnType as TypeImpl).appendTo(builder);
+      (returnType as TypeImpl).appendTo(buffer);
     }
   }
 
   /**
    * @return the base parameter elements of this function element, not `null`.
    */
   List<ParameterElement> get baseParameters {
     Element element = this.element;
     if (element is ExecutableElement) {
       return element.parameters;
@@ skipping 334 matching lines @@
 class HasAttributeSelectorElementImpl extends AngularSelectorElementImpl implements AngularHasAttributeSelectorElement {
   HasAttributeSelectorElementImpl(String attributeName, int offset) : super(attributeName, offset);
 
   @override
   bool apply(XmlTagNode node) {
     String attributeName = name;
     return node.getAttribute(attributeName) != null;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append("[");
-    builder.append(name);
-    builder.append("]");
+  void appendTo(StringBuffer buffer) {
+    buffer.write("[");
+    buffer.write(name);
+    buffer.write("]");
   }
 }
 
 /**
  * The interface `HideElementCombinator` defines the behavior of combinators that cause some
  * of the names in a namespace to be hidden when being imported.
  */
 abstract class HideElementCombinator implements NamespaceCombinator {
   /**
    * Return an array containing the names that are not to be made visible in the importing library
@@ skipping 10 matching lines @@
  */
 class HideElementCombinatorImpl implements HideElementCombinator {
   /**
    * The names that are not to be made visible in the importing library even if they are defined in
    * the imported library.
    */
   List<String> hiddenNames = StringUtilities.EMPTY_ARRAY;
 
   @override
   String toString() {
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append("show ");
+    StringBuffer buffer = new StringBuffer();
+    buffer.write("show ");
     int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.append(", ");
+        buffer.write(", ");
       }
-      builder.append(hiddenNames[i]);
+      buffer.write(hiddenNames[i]);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 }
 
 /**
  * The interface `HtmlElement` defines the behavior of elements representing an HTML file.
  */
 abstract class HtmlElement implements Element {
   /**
    * Return the [CompilationUnitElement] associated with this Angular HTML file, maybe
    * `null` if not an Angular file.
@@ skipping 118 matching lines @@
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
     safelyVisitChildren(_polymerTags, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     if (source == null) {
-      builder.append("{HTML file}");
+      buffer.write("{HTML file}");
     } else {
-      builder.append(source.fullName);
+      buffer.write(source.fullName);
     }
   }
 
   @override
   String get identifier => source.encoding;
 }
 
 /**
  * The interface `HtmlScriptElement` defines the behavior of elements representing a script
  * tag in an HTML file.
@@ skipping 123 matching lines @@
     setModifier(Modifier.DEFERRED, isDeferred);
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(prefix, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append("import ");
-    (importedLibrary as LibraryElementImpl).appendTo(builder);
+  void appendTo(StringBuffer buffer) {
+    buffer.write("import ");
+    (importedLibrary as LibraryElementImpl).appendTo(buffer);
   }
 
   @override
   String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${nameOffset}";
 }
 
 /**
  * The interface `InterfaceType` defines the behavior common to objects representing the type
  * introduced by either a class or an interface, or a reference to such a type.
  */
@@ skipping 481 matching lines @@
     List<DartType> typeArguments = this.typeArguments;
     bool allDynamic = true;
     for (DartType type in typeArguments) {
       if (type != null && !type.isDynamic) {
         allDynamic = false;
         break;
       }
     }
     // If there is at least one non-dynamic type, then list them out
     if (!allDynamic) {
-      JavaStringBuilder builder = new JavaStringBuilder();
-      builder.append(name);
-      builder.append("<");
+      StringBuffer buffer = new StringBuffer();
+      buffer.write(name);
+      buffer.write("<");
       for (int i = 0; i < typeArguments.length; i++) {
         if (i != 0) {
-          builder.append(", ");
+          buffer.write(", ");
         }
         DartType typeArg = typeArguments[i];
-        builder.append(typeArg.displayName);
+        buffer.write(typeArg.displayName);
       }
-      builder.append(">");
-      name = builder.toString();
+      buffer.write(">");
+      name = buffer.toString();
     }
     return name;
   }
 
   @override
   ClassElement get element => super.element as ClassElement;
 
   @override
   PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember.from((element as ClassElementImpl).getGetter(getterName), this);
 
@@ skipping 333 matching lines @@
     List<DartType> newTypeArguments = TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     if (JavaArrays.equals(newTypeArguments, typeArguments)) {
       return this;
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
     newType.typeArguments = newTypeArguments;
     return newType;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(name);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(name);
     int argumentCount = typeArguments.length;
     if (argumentCount > 0) {
-      builder.append("<");
+      buffer.write("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
-          builder.append(", ");
+          buffer.write(", ");
         }
-        (typeArguments[i] as TypeImpl).appendTo(builder);
+        (typeArguments[i] as TypeImpl).appendTo(buffer);
       }
-      builder.append(">");
+      buffer.write(">");
     }
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return (element == otherType.element) && TypeImpl.equalArrays(typeArguments, otherType.typeArguments, visitedElementPairs);
@@ skipping 1042 matching lines @@
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(type);
-    builder.append(" ");
-    builder.append(displayName);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(type);
+    buffer.write(" ");
+    buffer.write(displayName);
   }
 
   @override
   String get identifier => "${super.identifier}@${nameOffset}";
 }
 
 /**
  * The abstract class `Member` defines the behavior common to elements that represent members
  * of parameterized types.
  */
@@ skipping 264 matching lines @@
   /**
    * Set whether this method is static to correspond to the given value.
    *
    * @param isStatic `true` if the method is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(enclosingElement.displayName);
-    builder.append(".");
-    builder.append(displayName);
-    super.appendTo(builder);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(enclosingElement.displayName);
+    buffer.write(".");
+    buffer.write(displayName);
+    super.appendTo(buffer);
   }
 }
 
 /**
  * Instances of the class `MethodMember` represent a method element defined in a parameterized
  * type where the values of the type parameters are known.
  */
 class MethodMember extends ExecutableMember implements MethodElement {
   /**
    * If the given method's type is different when any type parameters from the defining type's
@@ skipping 43 matching lines @@
   MethodDeclaration get node => baseElement.node;
 
   @override
   bool get isAbstract => baseElement.isAbstract;
 
   @override
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append(baseElement.enclosingElement.displayName);
-    builder.append(".");
-    builder.append(baseElement.displayName);
-    builder.append("(");
+    StringBuffer buffer = new StringBuffer();
+    buffer.write(baseElement.enclosingElement.displayName);
+    buffer.write(".");
+    buffer.write(baseElement.displayName);
+    buffer.write("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.append(", ");
+        buffer.write(", ");
       }
-      builder.append(parameters[i]).toString();
+      buffer.write(parameters[i]);
     }
-    builder.append(")");
+    buffer.write(")");
     if (type != null) {
-      builder.append(Element.RIGHT_ARROW);
-      builder.append(type.returnType);
+      buffer.write(Element.RIGHT_ARROW);
+      buffer.write(type.returnType);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 }
 
 /**
  * The enumeration `Modifier` defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
  */
 class Modifier extends Enum<Modifier> {
   /**
    * Indicates that the modifier 'abstract' was applied to the element.
@@ skipping 296 matching lines @@
   }
 
   @override
   bool get isPublic => !isPrivate;
 
   @override
   bool get isSynthetic => true;
 
   @override
   String toString() {
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append("[");
+    StringBuffer buffer = new StringBuffer();
+    buffer.write("[");
     int count = conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.append(", ");
+        buffer.write(", ");
       }
-      (conflictingElements[i] as ElementImpl).appendTo(builder);
+      (conflictingElements[i] as ElementImpl).appendTo(buffer);
     }
-    builder.append("]");
-    return builder.toString();
+    buffer.write("]");
+    return buffer.toString();
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     // There are no children to visit
   }
 }
 
 /**
  * The interface [MultiplyInheritedExecutableElement] defines all of the behavior of an
@@ skipping 239 matching lines @@
     _visibleRangeLength = length;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     String left = "";
     String right = "";
     while (true) {
       if (parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
       } else if (parameterKind == ParameterKind.REQUIRED) {
       }
       break;
     }
-    builder.append(left);
-    appendToWithoutDelimiters(builder);
-    builder.append(right);
+    buffer.write(left);
+    appendToWithoutDelimiters(buffer);
+    buffer.write(right);
   }
 
   /**
    * Append the type and name of this parameter to the given builder.
    *
    * @param builder the builder to which the type and name are to be appended
    */
-  void appendToWithoutDelimiters(JavaStringBuilder builder) {
-    builder.append(type);
-    builder.append(" ");
-    builder.append(displayName);
+  void appendToWithoutDelimiters(StringBuffer buffer) {
+    buffer.write(type);
+    buffer.write(" ");
+    buffer.write(displayName);
     if (_defaultValueCode != null) {
       if (parameterKind == ParameterKind.NAMED) {
-        builder.append(": ");
+        buffer.write(": ");
       }
       if (parameterKind == ParameterKind.POSITIONAL) {
-        builder.append(" = ");
+        buffer.write(" = ");
       }
-      builder.append(_defaultValueCode);
+      buffer.write(_defaultValueCode);
     }
   }
 }
 
 /**
  * Instances of the class `ParameterMember` represent a parameter element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ParameterMember extends VariableMember implements ParameterElement {
   /**
@@ skipping 100 matching lines @@
       if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (baseElement.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
       } else if (baseElement.parameterKind == ParameterKind.REQUIRED) {
       }
       break;
     }
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append(left);
-    builder.append(type);
-    builder.append(" ");
-    builder.append(baseElement.displayName);
-    builder.append(right);
-    return builder.toString();
+    return '$left$type ${baseElement.displayName}$right';
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 
 /**
@@ skipping 292 matching lines @@
    * @param importedLibraries the libraries that are imported using this prefix
    */
   void set importedLibraries(List<LibraryElement> importedLibraries) {
     for (LibraryElement library in importedLibraries) {
       (library as LibraryElementImpl).enclosingElement = this;
     }
     this._importedLibraries = importedLibraries;
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append("as ");
-    super.appendTo(builder);
+  void appendTo(StringBuffer buffer) {
+    buffer.write("as ");
+    super.appendTo(buffer);
   }
 
   @override
   String get identifier => "_${super.identifier}";
 }
 
 /**
  * The interface `PropertyAccessorElement` defines the behavior of elements representing a
  * getter or a setter. Note that explicitly defined property accessors implicitly define a synthetic
  * field. Symmetrically, synthetic accessors are implicitly created for explicitly defined fields.
@@ skipping 187 matching lines @@
   /**
    * Set whether this accessor is static to correspond to the given value.
    *
    * @param isStatic `true` if the accessor is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(isGetter ? "get " : "set ");
-    builder.append(variable.displayName);
-    super.appendTo(builder);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(isGetter ? "get " : "set ");
+    buffer.write(variable.displayName);
+    super.appendTo(buffer);
   }
 
   @override
   String get identifier {
     String name = displayName;
     String suffix = isGetter ? "?" : "=";
     return "${name}${suffix}";
   }
 }
 
@@ skipping 96 matching lines @@
   bool get isGetter => baseElement.isGetter;
 
   @override
   bool get isSetter => baseElement.isSetter;
 
   @override
   String toString() {
     PropertyAccessorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer builder = new StringBuffer();
     if (isGetter) {
-      builder.append("get ");
+      builder.write("get ");
     } else {
-      builder.append("set ");
+      builder.write("set ");
     }
-    builder.append(baseElement.enclosingElement.displayName);
-    builder.append(".");
-    builder.append(baseElement.displayName);
-    builder.append("(");
+    builder.write(baseElement.enclosingElement.displayName);
+    builder.write(".");
+    builder.write(baseElement.displayName);
+    builder.write("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.append(", ");
+        builder.write(", ");
       }
-      builder.append(parameters[i]).toString();
+      builder.write(parameters[i]);
     }
-    builder.append(")");
+    builder.write(")");
     if (type != null) {
-      builder.append(Element.RIGHT_ARROW);
-      builder.append(type.returnType);
+      builder.write(Element.RIGHT_ARROW);
+      builder.write(type.returnType);
     }
     return builder.toString();
   }
 
   @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The interface `PropertyInducingElement` defines the behavior of elements representing a
@@ skipping 344 matching lines @@
    */
   int end = -1;
 
   /**
    * The offset of the 'show' keyword of this element.
    */
   int offset = 0;
 
   @override
   String toString() {
-    JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append("show ");
+    StringBuffer buffer = new StringBuffer();
+    buffer.write("show ");
     int count = shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.append(", ");
+        buffer.write(", ");
       }
-      builder.append(shownNames[i]);
+      buffer.write(shownNames[i]);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 }
 
 /**
  * Instances of the class `SimpleElementVisitor` implement an element visitor that will do
  * nothing when visiting an element. It is intended to be a superclass for classes that use the
  * visitor pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a
  * whole structure) and that only need to visit a small number of element types.
  */
 class SimpleElementVisitor<R> implements ElementVisitor<R> {
@@ skipping 358 matching lines @@
   bool isSupertypeOf(DartType type) => type.isSubtypeOf(this);
 
   @override
   bool get isUndefined => false;
 
   @override
   bool get isVoid => false;
 
   @override
   String toString() {
-    JavaStringBuilder builder = new JavaStringBuilder();
-    appendTo(builder);
-    return builder.toString();
+    StringBuffer buffer = new StringBuffer();
+    appendTo(buffer);
+    return buffer.toString();
   }
 
   /**
-   * Append a textual representation of this type to the given builder.
-   *
-   * @param builder the builder to which the text is to be appended
+   * Append a textual representation of this type to the given [buffer].
    */
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     if (name == null) {
-      builder.append("<unnamed type>");
+      buffer.write("<unnamed type>");
     } else {
-      builder.append(name);
+      buffer.write(name);
     }
   }
 
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs);
 
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs);
 
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs);
 }
 
@@ skipping 94 matching lines @@
    */
   TypeParameterElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
   @override
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
 
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(displayName);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(displayName);
     if (bound != null) {
-      builder.append(" extends ");
-      builder.append(bound);
+      buffer.write(" extends ");
+      buffer.write(bound);
     }
   }
 }
 
 /**
  * The interface `TypeParameterType` defines the behavior of objects representing the type
  * introduced by a type parameter.
  */
 abstract class TypeParameterType implements DartType {
   @override
@@ skipping 265 matching lines @@
       return false;
     } else if (identical(this, other)) {
       return true;
     } else {
       return javaSetEquals(_types, (other as UnionType).elements);
     }
   }
 
   @override
   String get displayName {
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     String prefix = "{";
     for (DartType t in _types) {
-      builder.append(prefix);
-      builder.append(t.displayName);
+      buffer.write(prefix);
+      buffer.write(t.displayName);
       prefix = ",";
     }
-    builder.append("}");
-    return builder.toString();
+    buffer.write("}");
+    return buffer.toString();
   }
 
   @override
   Set<DartType> get elements => _types;
 
   @override
   int get hashCode => _types.hashCode;
 
   @override
   DartType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
     List<DartType> out = new List<DartType>();
     for (DartType t in _types) {
       out.add(t.substitute2(argumentTypes, parameterTypes));
     }
     return union(new List.from(out));
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
+  void appendTo(StringBuffer buffer) {
     String prefix = "{";
-    for (DartType t in _types) {
-      builder.append(prefix);
-      (t as TypeImpl).appendTo(builder);
+    for (DartType type in _types) {
+      buffer.write(prefix);
+      (type as TypeImpl).appendTo(buffer);
       prefix = ",";
     }
-    builder.append("}");
+    buffer.write("}");
   }
 
   @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => this == object;
 
   @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // What version of subtyping do we want? See discussion below in [internalIsSubtypeOf].
     if (AnalysisEngine.instance.strictUnionTypes) {
       // The less unsound version: all.
@@ skipping 309 matching lines @@
     this._initializer = initializer;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
 
   @override
-  void appendTo(JavaStringBuilder builder) {
-    builder.append(type);
-    builder.append(" ");
-    builder.append(displayName);
+  void appendTo(StringBuffer buffer) {
+    buffer.write(type);
+    buffer.write(" ");
+    buffer.write(displayName);
   }
 }
 
 /**
  * The abstract class `VariableMember` defines the behavior common to members that represent a
  * variable element defined in a parameterized type where the values of the type parameters are
  * known.
  */
 abstract class VariableMember extends Member implements VariableElement {
   /**
@@ skipping 91 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }