Remove deprecated StringBuffer.add, addAll and addCharCode.

sdk/lib/_internal/compiler/implementation/lib/string_helper.dart

 // Copyright (c) 2012, 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 _js_helper;
 
 class StringMatch implements Match {
   const StringMatch(int this.start,
                     String this.str,
                     String this.pattern);
@@ skipping 68 matching lines @@
 
 stringReplaceAllUnchecked(receiver, from, to) {
   checkString(to);
   if (from is String) {
     if (from == "") {
       if (receiver == "") {
         return to;
       } else {
         StringBuffer result = new StringBuffer();
         int length = receiver.length;
-        result.add(to);
+        result.write(to);
         for (int i = 0; i < length; i++) {
-          result.add(receiver[i]);
-          result.add(to);
+          result.write(receiver[i]);
+          result.write(to);
         }
         return result.toString();
       }
     } else {
       var quoter = JS('', "new RegExp(#, 'g')", r'[-[\]{}()*+?.,\\^$|#\s]');
       var quoted = JS('String', r'#.replace(#, "\\$&")', from, quoter);
       var replacer = JS('', "new RegExp(#, 'g')", quoted);
       return stringReplaceJS(receiver, replacer, to);
     }
   } else if (from is JSSyntaxRegExp) {
@@ skipping 15 matching lines @@
   }
   if (onMatch == null) onMatch = _matchString;
   if (onNonMatch == null) onNonMatch = _stringIdentity;
   if (pattern is String) {
     return stringReplaceAllStringFuncUnchecked(receiver, pattern,
                                                onMatch, onNonMatch);
   }
   StringBuffer buffer = new StringBuffer();
   int startIndex = 0;
   for (Match match in pattern.allMatches(receiver)) {
-    buffer.add(onNonMatch(receiver.substring(startIndex, match.start)));
-    buffer.add(onMatch(match));
+    buffer.write(onNonMatch(receiver.substring(startIndex, match.start)));
+    buffer.write(onMatch(match));
     startIndex = match.end;
   }
-  buffer.add(onNonMatch(receiver.substring(startIndex)));
+  buffer.write(onNonMatch(receiver.substring(startIndex)));
   return buffer.toString();
 }
 
 stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch) {
   // Pattern is the empty string.
   StringBuffer buffer = new StringBuffer();
   int length = receiver.length;
   int i = 0;
-  buffer.add(onNonMatch(""));
+  buffer.write(onNonMatch(""));
   while (i < length) {
-    buffer.add(onMatch(new StringMatch(i, receiver, "")));
+    buffer.write(onMatch(new StringMatch(i, receiver, "")));
     // Special case to avoid splitting a surrogate pair.
     int code = receiver.codeUnitAt(i);
     if ((code & ~0x3FF) == 0xD800 && length > i + 1) {
       // Leading surrogate;
       code = receiver.codeUnitAt(i + 1);
       if ((code & ~0x3FF) == 0xDC00) {
         // Matching trailing surrogate.
-        buffer.add(onNonMatch(receiver.substring(i, i + 2)));
+        buffer.write(onNonMatch(receiver.substring(i, i + 2)));
         i += 2;
         continue;
       }
     }
-    buffer.add(onNonMatch(receiver[i]));
+    buffer.write(onNonMatch(receiver[i]));
     i++;
   }
-  buffer.add(onMatch(new StringMatch(i, receiver, "")));
-  buffer.add(onNonMatch(""));
+  buffer.write(onMatch(new StringMatch(i, receiver, "")));
+  buffer.write(onNonMatch(""));
   return buffer.toString();
 }
 
 stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch) {
   int patternLength = pattern.length;
   if (patternLength == 0) {
     return stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch);
   }
   int length = receiver.length;
   StringBuffer buffer = new StringBuffer();
   int startIndex = 0;
   while (startIndex < length) {
     int position = receiver.indexOf(pattern, startIndex);
     if (position == -1) {
       break;
     }
-    buffer.add(onNonMatch(receiver.substring(startIndex, position)));
-    buffer.add(onMatch(new StringMatch(position, receiver, pattern)));
+    buffer.write(onNonMatch(receiver.substring(startIndex, position)));
+    buffer.write(onMatch(new StringMatch(position, receiver, pattern)));
     startIndex = position + patternLength;
   }
-  buffer.add(onNonMatch(receiver.substring(startIndex)));
+  buffer.write(onNonMatch(receiver.substring(startIndex)));
   return buffer.toString();
 }
 
 
 stringReplaceFirstUnchecked(receiver, from, to) {
   if (from is String) {
     return stringReplaceJS(receiver, from, to);
   } else if (from is JSSyntaxRegExp) {
     var re = regExpGetNative(from);
     return stringReplaceJS(receiver, re, to);
   } else {
     checkNull(from);
     // TODO(floitsch): implement generic String.replace (with patterns).
     throw "String.replace(Pattern) UNIMPLEMENTED";
   }
 }
 
 stringJoinUnchecked(array, separator) {
   return JS('String', r'#.join(#)', array, separator);
 }