Remove JavaStringBuilder

pkg/analyzer/lib/src/generated/ast.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.ast;
 
 import 'dart:collection';
@@ skipping 51 matching lines @@
    * @return the strings that are implicitly concatenated
    */
   NodeList<StringLiteral> get strings => _strings;
 
   @override
   void visitChildren(AstVisitor visitor) {
     _strings.accept(visitor);
   }
 
   @override
-  void appendStringValue(JavaStringBuilder builder) {
+  void appendStringValue(StringBuffer buffer) {
     for (StringLiteral stringLiteral in strings) {
-      stringLiteral.appendStringValue(builder);
+      stringLiteral.appendStringValue(buffer);
     }
   }
 }
 
 /**
  * The abstract class `AnnotatedNode` defines the behavior of nodes that can be annotated with
  * both a comment and metadata.
  */
 abstract class AnnotatedNode extends AstNode {
   /**
@@ skipping 4434 matching lines @@
  */
 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();
 
   @override
   Object visitAdjacentStrings(AdjacentStrings node) {
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     for (StringLiteral string in node.strings) {
       Object value = string.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
-      builder.append(value);
+      buffer.write(value);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     Object leftOperand = node.leftOperand.accept(this);
     if (identical(leftOperand, NOT_A_CONSTANT)) {
       return leftOperand;
     }
     Object rightOperand = node.rightOperand.accept(this);
     if (identical(rightOperand, NOT_A_CONSTANT)) {
@@ skipping 242 matching lines @@
   Object visitPropertyAccess(PropertyAccess node) => _getConstantValue(null);
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) => _getConstantValue(null);
 
   @override
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => node.value;
 
   @override
   Object visitStringInterpolation(StringInterpolation node) {
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     for (InterpolationElement element in node.elements) {
       Object value = element.accept(this);
       if (identical(value, NOT_A_CONSTANT)) {
         return value;
       }
-      builder.append(value);
+      buffer.write(value);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 
   @override
   Object visitSymbolLiteral(SymbolLiteral node) {
     // TODO(brianwilkerson) This isn't optimal because a Symbol is not a String.
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     for (Token component in node.components) {
-      if (builder.length > 0) {
-        builder.appendChar(0x2E);
+      if (buffer.length > 0) {
+        buffer.writeCharCode(0x2E);

[scheglov, 2014/10/26 19:13:53]

buffer.write('.') here and everywhere else?

[Brian Wilkerson, 2014/10/26 20:16:36]

As long as there isn't a performance penalty, then yes, but in a later CL.

       }
-      builder.append(component.lexeme);
+      buffer.write(component.lexeme);
     }
-    return builder.toString();
+    return buffer.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) {
     // TODO(brianwilkerson) Implement this
@@ skipping 5986 matching lines @@
    *
    * @return the components of the identifier
    */
   NodeList<SimpleIdentifier> get components => _components;
 
   @override
   Token get endToken => _components.endToken;
 
   @override
   String get name {
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     bool needsPeriod = false;
     for (SimpleIdentifier identifier in _components) {
       if (needsPeriod) {
-        builder.append(".");
+        buffer.write(".");
       } else {
         needsPeriod = true;
       }
-      builder.append(identifier.name);
+      buffer.write(identifier.name);
     }
-    return builder.toString();
+    return buffer.toString();
   }
 
   @override
   int get precedence => 15;
 
   @override
   Element get propagatedElement => null;
 
   @override
   Element get staticElement => null;
@@ skipping 5248 matching lines @@
   void set value(String string) {
     _value = StringUtilities.intern(_value);
   }
 
   @override
   void visitChildren(AstVisitor visitor) {
     // There are no children to visit.
   }
 
   @override
-  void appendStringValue(JavaStringBuilder builder) {
-    builder.append(value);
+  void appendStringValue(StringBuffer buffer) {
+    buffer.write(value);
   }
 }
 
 /**
  * Instances of the class `Statement` defines the behavior common to nodes that represent a
  * statement.
  *
  * <pre>
  * statement ::=
  *     [Block]
@@ skipping 55 matching lines @@
 
   @override
   Token get endToken => _elements.endToken;
 
   @override
   void visitChildren(AstVisitor visitor) {
     _elements.accept(visitor);
   }
 
   @override
-  void appendStringValue(JavaStringBuilder builder) {
+  void appendStringValue(StringBuffer buffer) {
     throw new IllegalArgumentException();
   }
 
   @override
   int get contentsOffset {
     InterpolationString element = _elements.first;
     return element.contentsOffset;
   }
 
   @override
@@ skipping 30 matching lines @@
  *
  * <pre>
  * stringLiteral ::=
  *     [SimpleStringLiteral]
  *   | [AdjacentStrings]
  *   | [StringInterpolation]
  * </pre>
  */
 abstract class StringLiteral extends Literal {
   /**
-   * Return the value of the string literal, or `null` if the string is not a constant string
-   * without any string interpolation.
-   *
-   * @return the value of the string literal
+   * Return the value of the string literal, or `null` if the string is not a
+   * constant string without any string interpolation.
    */
   String get stringValue {
-    JavaStringBuilder builder = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     try {
-      appendStringValue(builder);
+      appendStringValue(buffer);
     } on IllegalArgumentException catch (exception) {
       return null;
     }
-    return builder.toString();
+    return buffer.toString();
   }
 
   /**
-   * Append the value of the given string literal to the given string builder.
-   *
-   * @param builder the builder to which the string's value is to be appended
-   * @throws IllegalArgumentException if the string is not a constant string without any string
-   *           interpolation
+   * Append the value of this string literal to the given [buffer]. Throw an
+   * [IllegalArgumentException] if the string is not a constant string without
+   * any string interpolation.
    */
-  void appendStringValue(JavaStringBuilder builder);
+  void appendStringValue(StringBuffer buffer);
 }
 
 /**
  * Instances of the class [SingleStringLiteral] represent a single string
  * literal expression.
  *
  * <pre>
  * singleStringLiteral ::=
  *     [SimpleStringLiteral]
  *   | [StringInterpolation]
@@ skipping 3440 matching lines @@
     _elements[index] = node;
   }
   void clear() {
     _elements = <E> [];
   }
   int get length => _elements.length;
   void set length(int value) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 }