Remove deprecated StringBuffer.add, addAll and addCharCode.

sdk/lib/_collection_dev/to_string.dart

 // Copyright (c) 2013, 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.
 
 part of dart._collection.dev;
 
 /**
  * Temporary move `toString` methods into this class.
  */
 class ToString {
@@ skipping 33 matching lines @@
    * emitted into [:result:]). The [:visiting:] parameter allows this method to
    * generate a [:'[...]':] or [:'{...}':] where required. In other words,
    * it allows this method and [_emitMap] to identify recursive collections
    * and maps.
    */
   static void _emitCollection(Collection c,
                               StringBuffer result,
                               List visiting) {
     visiting.add(c);
     bool isList = c is List;
-    result.add(isList ? '[' : '{');
+    result.write(isList ? '[' : '{');
 
     bool first = true;
     for (var e in c) {
       if (!first) {
-        result.add(', ');
+        result.write(', ');
       }
       first = false;
       _emitObject(e, result, visiting);
     }
 
-    result.add(isList ? ']' : '}');
+    result.write(isList ? ']' : '}');
     visiting.removeLast();
   }
 
   /**
    * Appends a string representing the specified object to the specified
    * string buffer. If the object is a [Collection] or [Map], it is formatted
    * as per [collectionToString] or [mapToString]; otherwise, it is formatted
    * by invoking its own [toString] method.
    *
    * The [:visiting:] list contains references to all of the enclosing
    * collections and maps (which are currently in the process of being
    * emitted into [:result:]). The [:visiting:] parameter allows this method
    * to generate a [:'[...]':] or [:'{...}':] where required. In other words,
    * it allows this method and [_emitCollection] to identify recursive maps
    * and collections.
    */
   static void _emitObject(Object o, StringBuffer result, List visiting) {
     if (o is Collection) {
       if (_containsRef(visiting, o)) {
-        result.add(o is List ? '[...]' : '{...}');
+        result.write(o is List ? '[...]' : '{...}');
       } else {
         _emitCollection(o, result, visiting);
       }
     } else if (o is Map) {
       if (_containsRef(visiting, o)) {
-        result.add('{...}');
+        result.write('{...}');
       } else {
         _emitMap(o, result, visiting);
       }
     } else { // o is neither a collection nor a map
-      result.add(o);
+      result.write(o);
     }
   }
 
   /**
    * Returns true if the specified collection contains the specified object
    * reference.
    */
   static _containsRef(Collection c, Object ref) {
     for (var e in c) {
       if (identical(e, ref)) return true;
@@ skipping 28 matching lines @@
    * string buffer. The string is formatted as per [mapToString].
    * The [:visiting:] list contains references to all of the enclosing
    * collections and maps (which are currently in the process of being
    * emitted into [:result:]). The [:visiting:] parameter allows this method
    * to generate a [:'[...]':] or [:'{...}':] where required. In other words,
    * it allows this method and [_emitCollection] to identify recursive maps
    * and collections.
    */
   static void _emitMap(Map m, StringBuffer result, List visiting) {
     visiting.add(m);
-    result.add('{');
+    result.write('{');
 
     bool first = true;
     m.forEach((k, v) {
       if (!first) {
-        result.add(', ');
+        result.write(', ');
       }
       first = false;
       _emitObject(k, result, visiting);
-      result.add(': ');
+      result.write(': ');
       _emitObject(v, result, visiting);
     });
 
-    result.add('}');
+    result.write('}');
     visiting.removeLast();
   }
 }