Use limited JavaStringBuilder implementation instead of Dart StringBuffer.

pkg/analyzer-experimental/lib/src/generated/element.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.element;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
@@ skipping 1398 matching lines @@
     setModifier(Modifier.MIXIN, isValidMixin);
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
-  void appendTo(StringBuffer builder) {
+  void appendTo(JavaStringBuilder builder) {
     String name11 = name;
     if (name11 == null) {
-      builder.write("{unnamed class}");
+      builder.append("{unnamed class}");
     } else {
-      builder.write(name11);
+      builder.append(name11);
     }
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
-      builder.write("<");
+      builder.append("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
-          builder.write(", ");
+          builder.append(", ");
         }
         ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
       }
-      builder.write(">");
+      builder.append(">");
     }
   }
   void collectAllSupertypes(Collection<InterfaceType> list) {
     if (_supertype == null || list.contains(_supertype)) {
       return;
     }
     list.add(_supertype);
     ((_supertype.element as ClassElementImpl)).collectAllSupertypes(list);
     for (InterfaceType type in interfaces) {
       if (!list.contains(type)) {
@@ skipping 188 matching lines @@
     this._types = types2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
   }
-  void appendTo(StringBuffer builder) {
+  void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
-      builder.write("{compilation unit}");
+      builder.append("{compilation unit}");
     } else {
-      builder.write(_source.fullName);
+      builder.append(_source.fullName);
     }
   }
 }
 /**
  * Instances of the class {@code ConstructorElementImpl} implement a {@code ConstructorElement}.
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
    * An empty array of constructor elements.
    */
@@ skipping 10 matching lines @@
   bool isConst() => hasModifier(Modifier.CONST);
   bool isFactory() => hasModifier(Modifier.FACTORY);
   bool isStatic() => false;
   /**
    * Set whether this constructor represents a factory method to the given value.
    * @param isFactory {@code true} if this constructor represents a factory method
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(enclosingElement.name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(enclosingElement.name);
     String name12 = name;
     if (name12 != null && !name12.isEmpty) {
-      builder.write(".");
-      builder.write(name12);
+      builder.append(".");
+      builder.append(name12);
     }
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code DynamicElementImpl} represent the synthetic element representing
  * the declaration of the type {@code dynamic}.
  */
 class DynamicElementImpl extends ElementImpl {
   /**
@@ skipping 127 matching lines @@
     this._metadata = metadata2;
   }
   /**
    * Set whether this element is synthetic to correspond to the given value.
    * @param isSynthetic {@code true} if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
   String toString() {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
   void visitChildren(ElementVisitor<Object> visitor) {
   }
   /**
    * Append a textual representation of this type to the given builder.
    * @param builder the builder to which the text is to be appended
    */
-  void appendTo(StringBuffer builder) {
+  void appendTo(JavaStringBuilder builder) {
     if (_name == null) {
-      builder.write("<unnamed ");
-      builder.write(runtimeType.toString());
-      builder.write(">");
+      builder.append("<unnamed ");
+      builder.append(runtimeType.toString());
+      builder.append(">");
     } else {
-      builder.write(_name);
+      builder.append(_name);
     }
   }
   /**
    * Return an identifier that uniquely identifies this element among the children of this element's
    * parent.
    * @return an identifier that uniquely identifies this element relative to its parent
    */
   String get identifier => name;
   /**
    * Return {@code true} if this element has the given modifier associated with it.
@@ skipping 88 matching lines @@
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     return JavaArrays.equals(_components, location._components);
   }
   /**
    * Return the path to the element whose location is represented by this object.
    * @return the path to the element whose location is represented by this object
    */
   List<String> get components => _components;
   String get encoding {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     int length2 = _components.length;
     for (int i = 0; i < length2; i++) {
       if (i > 0) {
-        builder.writeCharCode(_SEPARATOR_CHAR);
+        builder.appendChar(_SEPARATOR_CHAR);
       }
       encode(builder, _components[i]);
     }
     return builder.toString();
   }
   int get hashCode => JavaArrays.makeHashCode(_components);
   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>();
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     int index = 0;
     int length3 = encoding.length;
     while (index < length3) {
       int currentChar = encoding.codeUnitAt(index);
       if (currentChar == _SEPARATOR_CHAR) {
         if (index + 1 < length3 && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
-          builder.writeCharCode(_SEPARATOR_CHAR);
+          builder.appendChar(_SEPARATOR_CHAR);
           index += 2;
         } else {
           components.add(builder.toString());
-          builder.clear();
+          builder.length = 0;
           index++;
         }
       } else {
-        builder.writeCharCode(currentChar);
+        builder.appendChar(currentChar);
         index++;
       }
     }
     if (builder.length > 0) {
       components.add(builder.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(StringBuffer builder, String component) {
+  void encode(JavaStringBuilder builder, String component) {
     int length4 = component.length;
     for (int i = 0; i < length4; i++) {
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
-        builder.writeCharCode(_SEPARATOR_CHAR);
+        builder.appendChar(_SEPARATOR_CHAR);
       }
-      builder.writeCharCode(currentChar);
+      builder.appendChar(currentChar);
     }
   }
 }
 /**
  * The abstract class {@code ExecutableElementImpl} implements the behavior common to{@code ExecutableElement}s.
  */
 abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
   /**
    * An array containing all of the functions defined within this executable element.
    */
@@ skipping 113 matching lines @@
   void set type(FunctionType type7) {
     this._type = type7;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_labels, visitor);
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
-  void appendTo(StringBuffer builder) {
-    builder.write("(");
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.write(", ");
+        builder.append(", ");
       }
       ((_parameters[i] as ParameterElementImpl)).appendTo(builder);
     }
-    builder.write(")");
+    builder.append(")");
     if (_type != null) {
-      builder.write(" -> ");
-      builder.write(_type.returnType);
+      builder.append(" -> ");
+      builder.append(_type.returnType);
     }
   }
 }
 /**
  * Instances of the class {@code ExportElementImpl} implement an {@link ExportElement}.
  */
 class ExportElementImpl extends ElementImpl implements ExportElement {
   /**
    * The library that is exported from this library by this export directive.
    */
@@ skipping 21 matching lines @@
     this._combinators = combinators2;
   }
   /**
    * Set the library that is exported from this library by this import directive to the given
    * library.
    * @param exportedLibrary the library that is exported from this library
    */
   void set exportedLibrary(LibraryElement exportedLibrary2) {
     this._exportedLibrary = exportedLibrary2;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write("export ");
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("export ");
     ((_exportedLibrary as LibraryElementImpl)).appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code FieldElementImpl} implement a {@code FieldElement}.
  */
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
    * An empty array of field elements.
    */
@@ skipping 77 matching lines @@
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    * @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 {@code -1} if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
-  void appendTo(StringBuffer builder) {
+  void appendTo(JavaStringBuilder builder) {
     String name13 = name;
     if (name13 != null) {
-      builder.write(name13);
+      builder.append(name13);
     }
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code ShowCombinatorImpl} implement a {@link ShowCombinator}.
  */
 class HideCombinatorImpl implements HideCombinator {
   /**
    * 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;
   /**
    * Initialize a newly created combinator.
    */
   HideCombinatorImpl() : super() {
   }
   List<String> get hiddenNames => _hiddenNames;
   /**
    * Set the names that are not to be made visible in the importing library even if they are defined
    * in the imported library to the given names.
    * @param hiddenNames the names that are not to be made visible in the importing library
    */
   void set hiddenNames(List<String> hiddenNames2) {
     this._hiddenNames = hiddenNames2;
   }
   String toString() {
-    StringBuffer builder = new StringBuffer();
-    builder.write("show ");
+    JavaStringBuilder builder = new JavaStringBuilder();
+    builder.append("show ");
     int count = _hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.write(", ");
+        builder.append(", ");
       }
-      builder.write(_hiddenNames[i]);
+      builder.append(_hiddenNames[i]);
     }
     return builder.toString();
   }
 }
 /**
  * Instances of the class {@code HtmlElementImpl} implement an {@link HtmlElement}.
  */
 class HtmlElementImpl extends ElementImpl implements HtmlElement {
   /**
    * An empty array of HTML file elements.
@@ skipping 38 matching lines @@
    * Set the source that corresponds to this HTML file to the given source.
    * @param source the source that corresponds to this HTML file
    */
   void set source(Source source6) {
     this._source = source6;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_libraries, visitor);
   }
-  void appendTo(StringBuffer builder) {
+  void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
-      builder.write("{HTML file}");
+      builder.append("{HTML file}");
     } else {
-      builder.write(_source.fullName);
+      builder.append(_source.fullName);
     }
   }
 }
 /**
  * Instances of the class {@code ImportElementImpl} implement an {@link ImportElement}.
  */
 class ImportElementImpl extends ElementImpl implements ImportElement {
   /**
    * The library that is imported into this library by this import directive.
    */
@@ skipping 38 matching lines @@
    * Set the prefix that was specified as part of the import directive to the given prefix.
    * @param prefix the prefix that was specified as part of the import directive
    */
   void set prefix(PrefixElement prefix3) {
     this._prefix = prefix3;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
   }
-  void appendTo(StringBuffer builder) {
-    builder.write("import ");
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code LabelElementImpl} implement a {@code LabelElement}.
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a {@code switch} statement.
    */
@@ skipping 239 matching lines @@
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    * @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 {@code -1} if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(type);
-    builder.write(" ");
-    builder.write(name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(type);
+    builder.append(" ");
+    builder.append(name);
   }
 }
 /**
  * Instances of the class {@code MethodElementImpl} implement a {@code MethodElement}.
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty array of method elements.
    */
   static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
@@ skipping 29 matching lines @@
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
   /**
    * Set whether this method is static to correspond to the given value.
    * @param isStatic {@code true} if the method is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(enclosingElement.name);
-    builder.write(".");
-    builder.write(name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(enclosingElement.name);
+    builder.append(".");
+    builder.append(name);
     super.appendTo(builder);
   }
 }
 /**
  * The enumeration {@code Modifier} defines constants for all of the modifiers defined by the Dart
  * language and for a few additional flags that are useful.
  */
 class Modifier {
   static final Modifier ABSTRACT = new Modifier('ABSTRACT', 0);
   static final Modifier CONST = new Modifier('CONST', 1);
@@ skipping 55 matching lines @@
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in _conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
   bool isSynthetic() => true;
   String toString() {
-    StringBuffer builder = new StringBuffer();
-    builder.write("[");
+    JavaStringBuilder builder = new JavaStringBuilder();
+    builder.append("[");
     int count = _conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.write(", ");
+        builder.append(", ");
       }
       ((_conflictingElements[i] as ElementImpl)).appendTo(builder);
     }
-    builder.write("]");
+    builder.append("]");
     return builder.toString();
   }
   void visitChildren(ElementVisitor<Object> visitor) {
   }
   /**
    * Add the given element to the list of elements. If the element is a multiply-defined element,
    * add all of the conflicting elements that it represents.
    * @param elements the list to which the element(s) are to be added
    * @param element the element(s) to be added
    */
@@ skipping 76 matching lines @@
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    * @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 {@code -1} if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(type);
-    builder.write(" ");
-    builder.write(name);
-    builder.write(" (");
-    builder.write(kind);
-    builder.write(")");
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(type);
+    builder.append(" ");
+    builder.append(name);
+    builder.append(" (");
+    builder.append(kind);
+    builder.append(")");
   }
 }
 /**
  * Instances of the class {@code PrefixElementImpl} implement a {@code PrefixElement}.
  */
 class PrefixElementImpl extends ElementImpl implements PrefixElement {
   /**
    * An array containing all of the libraries that are imported using this prefix.
    */
   List<LibraryElement> _importedLibraries = LibraryElementImpl.EMPTY_ARRAY;
@@ skipping 14 matching lines @@
   /**
    * Set the libraries that are imported using this prefix to the given libraries.
    * @param importedLibraries the libraries that are imported using this prefix
    */
   void set importedLibraries(List<LibraryElement> importedLibraries2) {
     for (LibraryElement library in importedLibraries2) {
       ((library as LibraryElementImpl)).enclosingElement = this;
     }
     this._importedLibraries = importedLibraries2;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write("as ");
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("as ");
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code PropertyAccessorElementImpl} implement a{@code PropertyAccessorElement}.
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
    * The variable associated with this accessor.
    */
@@ skipping 49 matching lines @@
   void set setter(bool isSetter) {
     setModifier(Modifier.SETTER, isSetter);
   }
   /**
    * Set the variable associated with this accessor to the given variable.
    * @param variable the variable associated with this accessor
    */
   void set variable(PropertyInducingElement variable3) {
     this._variable = variable3;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(isGetter() ? "get " : "set ");
-    builder.write(variable.name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(isGetter() ? "get " : "set ");
+    builder.append(variable.name);
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code PropertyInducingElementImpl} implement a{@code PropertyInducingElement}.
  */
 abstract class PropertyInducingElementImpl extends VariableElementImpl implements PropertyInducingElement {
   /**
    * The getter associated with this element.
    */
@@ skipping 59 matching lines @@
   List<String> get shownNames => _shownNames;
   /**
    * Set the names that are to be made visible in the importing library if they are defined in the
    * imported library to the given names.
    * @param shownNames the names that are to be made visible in the importing library
    */
   void set shownNames(List<String> shownNames2) {
     this._shownNames = shownNames2;
   }
   String toString() {
-    StringBuffer builder = new StringBuffer();
-    builder.write("show ");
+    JavaStringBuilder builder = new JavaStringBuilder();
+    builder.append("show ");
     int count = _shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
-        builder.write(", ");
+        builder.append(", ");
       }
-      builder.write(_shownNames[i]);
+      builder.append(_shownNames[i]);
     }
     return builder.toString();
   }
 }
 /**
  * Instances of the class {@code TopLevelVariableElementImpl} implement a{@code TopLevelVariableElement}.
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl implements TopLevelVariableElement {
   /**
    * An empty array of top-level variable elements.
@@ skipping 93 matching lines @@
     for (TypeVariableElement variable in typeVariables3) {
       ((variable as TypeVariableElementImpl)).enclosingElement = this;
     }
     this._typeVariables = typeVariables3;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
-  void appendTo(StringBuffer builder) {
-    builder.write("typedef ");
-    builder.write(name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("typedef ");
+    builder.append(name);
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
-      builder.write("<");
+      builder.append("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
-          builder.write(", ");
+          builder.append(", ");
         }
         ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
       }
-      builder.write(">");
+      builder.append(">");
     }
-    builder.write("(");
+    builder.append("(");
     int parameterCount = _parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
-        builder.write(", ");
+        builder.append(", ");
       }
       ((_parameters[i] as ParameterElementImpl)).appendTo(builder);
     }
-    builder.write(")");
+    builder.append(")");
     if (_type != null) {
-      builder.write(" -> ");
-      builder.write(_type.returnType);
+      builder.append(" -> ");
+      builder.append(_type.returnType);
     }
   }
 }
 /**
  * Instances of the class {@code TypeVariableElementImpl} implement a {@code TypeVariableElement}.
  */
 class TypeVariableElementImpl extends ElementImpl implements TypeVariableElement {
   /**
    * The type defined by this type variable.
    */
@@ skipping 24 matching lines @@
   void set bound(Type2 bound2) {
     this._bound = bound2;
   }
   /**
    * Set the type defined by this type variable to the given type
    * @param type the type defined by this type variable
    */
   void set type(TypeVariableType type9) {
     this._type = type9;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(name);
     if (_bound != null) {
-      builder.write(" extends ");
-      builder.write(_bound);
+      builder.append(" extends ");
+      builder.append(_bound);
     }
   }
 }
 /**
  * Instances of the class {@code VariableElementImpl} implement a {@code VariableElement}.
  */
 abstract class VariableElementImpl extends ElementImpl implements VariableElement {
   /**
    * The declared type of this variable.
    */
@@ skipping 59 matching lines @@
    * Set the declared type of this variable to the given type.
    * @param type the declared type of this variable
    */
   void set type(Type2 type10) {
     this._type = type10;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(type);
-    builder.write(" ");
-    builder.write(name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(type);
+    builder.append(" ");
+    builder.append(name);
   }
 }
 /**
  * The unique instance of the class {@code BottomTypeImpl} implements the type {@code bottom}.
  */
 class BottomTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static BottomTypeImpl _INSTANCE = new BottomTypeImpl();
@@ skipping 260 matching lines @@
       return this;
     }
     Element element38 = element;
     FunctionTypeImpl newType = (element38 is ExecutableElement) ? new FunctionTypeImpl.con1((element38 as ExecutableElement)) : new FunctionTypeImpl.con2((element38 as TypeAliasElement));
     newType.returnType = _returnType.substitute2(argumentTypes, parameterTypes);
     newType.normalParameterTypes = TypeImpl.substitute(_normalParameterTypes, argumentTypes, parameterTypes);
     newType.optionalParameterTypes = TypeImpl.substitute(_optionalParameterTypes, argumentTypes, parameterTypes);
     newType._namedParameterTypes = substitute3(_namedParameterTypes, argumentTypes, parameterTypes);
     return newType;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write("(");
+  void appendTo(JavaStringBuilder builder) {
+    builder.append("(");
     bool needsComma = false;
     if (_normalParameterTypes.length > 0) {
       for (Type2 type in _normalParameterTypes) {
         if (needsComma) {
-          builder.write(", ");
+          builder.append(", ");
         } else {
           needsComma = true;
         }
         ((type as TypeImpl)).appendTo(builder);
       }
     }
     if (_optionalParameterTypes.length > 0) {
       if (needsComma) {
-        builder.write(", ");
+        builder.append(", ");
         needsComma = false;
       }
-      builder.write("[");
+      builder.append("[");
       for (Type2 type in _optionalParameterTypes) {
         if (needsComma) {
-          builder.write(", ");
+          builder.append(", ");
         } else {
           needsComma = true;
         }
         ((type as TypeImpl)).appendTo(builder);
       }
-      builder.write("]");
+      builder.append("]");
       needsComma = true;
     }
     if (_namedParameterTypes.length > 0) {
       if (needsComma) {
-        builder.write(", ");
+        builder.append(", ");
         needsComma = false;
       }
-      builder.write("{");
+      builder.append("{");
       for (MapEntry<String, Type2> entry in getMapEntrySet(_namedParameterTypes)) {
         if (needsComma) {
-          builder.write(", ");
+          builder.append(", ");
         } else {
           needsComma = true;
         }
-        builder.write(entry.getKey());
-        builder.write(": ");
+        builder.append(entry.getKey());
+        builder.append(": ");
         ((entry.getValue() as TypeImpl)).appendTo(builder);
       }
-      builder.write("}");
+      builder.append("}");
       needsComma = true;
     }
-    builder.write(") -> ");
+    builder.append(") -> ");
     if (_returnType == null) {
-      builder.write("null");
+      builder.append("null");
     } else {
       ((_returnType as TypeImpl)).appendTo(builder);
     }
   }
 }
 /**
  * Instances of the class {@code InterfaceTypeImpl} 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 284 matching lines @@
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0) {
       return this;
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
     newType.typeArguments = TypeImpl.substitute(_typeArguments, argumentTypes, parameterTypes);
     return newType;
   }
-  void appendTo(StringBuffer builder) {
-    builder.write(name);
+  void appendTo(JavaStringBuilder builder) {
+    builder.append(name);
     int argumentCount = _typeArguments.length;
     if (argumentCount > 0) {
-      builder.write("<");
+      builder.append("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
-          builder.write(", ");
+          builder.append(", ");
         }
         ((_typeArguments[i] as TypeImpl)).appendTo(builder);
       }
-      builder.write(">");
+      builder.append(">");
     }
   }
 }
 /**
  * The abstract class {@code TypeImpl} implements the behavior common to objects representing the
  * declared type of elements in the element model.
  */
 abstract class TypeImpl implements Type2 {
   /**
    * Return an array containing the results of using the given argument types and parameter types to
@@ skipping 39 matching lines @@
   Element get element => _element;
   Type2 getLeastUpperBound(Type2 type) => null;
   String get name => _name;
   bool isAssignableTo(Type2 type) => this.isSubtypeOf(type) || type.isSubtypeOf(this);
   bool isDartCoreFunction() => false;
   bool isDynamic() => false;
   bool isMoreSpecificThan(Type2 type) => false;
   bool isSupertypeOf(Type2 type) => type.isSubtypeOf(this);
   bool isVoid() => false;
   String toString() {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
   /**
    * Append a textual representation of this type to the given builder.
    * @param builder the builder to which the text is to be appended
    */
-  void appendTo(StringBuffer builder) {
+  void appendTo(JavaStringBuilder builder) {
     if (_name == null) {
-      builder.write("<unnamed type>");
+      builder.append("<unnamed type>");
     } else {
-      builder.write(_name);
+      builder.append(_name);
     }
   }
 }
 /**
  * Instances of the class {@code TypeVariableTypeImpl} defines the behavior of objects representing
  * the type introduced by a type variable.
  */
 class TypeVariableTypeImpl extends TypeImpl implements TypeVariableType {
   /**
    * Return an array containing the type variable types defined by the given array of type variable
@@ skipping 361 matching lines @@
  */
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }