Remove deprecated StringBuffer.add, addAll and addCharCode.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 117 matching lines @@
       : mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
         interceptorClosureCache = new Map<int, String>(),
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void addComment(String comment, CodeBuffer buffer) {
-    buffer.add(jsAst.prettyPrint(js.comment(comment), compiler));
+    buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
   void computeRequiredTypeChecks() {
     assert(checkedClasses == null && checkedTypedefs == null);
 
     compiler.codegenWorld.addImplicitChecks(classesUsingTypeVariableTests);
 
     checkedClasses = new Set<ClassElement>();
     checkedTypedefs = new Set<TypedefElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
@@ skipping 462 matching lines @@
 
   List buildFinishIsolateConstructor() {
     return [
       // $finishIsolateConstructorName = $finishIsolateConstructorFunction
       js[finishIsolateConstructorName].assign(finishIsolateConstructorFunction)
     ];
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.isolateName;
-    buffer.add("$isolate = $finishIsolateConstructorName($isolate)$N");
+    buffer.write("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /**
    * Generate stubs to handle invocation of methods with optional
    * arguments.
    *
    * A method like [: foo([x]) :] may be invoked by the following
    * calls: [: foo(), foo(1), foo(x: 1) :]. See the sources of this
    * function for detailed examples.
    */
@@ skipping 386 matching lines @@
     /**
      * Generates a holder object if it is needed.  A holder is a JavaScript
      * object literal with a field [builtin$cls] that contains the name of the
      * class as a string (just like object constructors do).  The is-checks for
      * the class are are added to the holder object later.
      */
     void maybeGenerateHolder(ClassElement cls) {
       if (!needsHolder(cls)) return;
       String holder = namer.isolateAccess(cls);
       String name = namer.getName(cls);
-      buffer.add('$holder$_=$_{builtin\$cls:$_"$name"');
-      buffer.add('}$N');
+      buffer.write('$holder$_=$_{builtin\$cls:$_"$name"');
+      buffer.write('}$N');
     }
 
     // Create representation objects for classes that we do not have a class
     // definition for (because they are uninstantiated or native).
     for (ClassElement cls in rti.allArguments) {
       maybeGenerateHolder(cls);
     }
 
     // Add checks to the constructors of instantiated classes or to the created
     // holder object.
     for (ClassElement cls in typeChecks) {
       String holder = namer.isolateAccess(cls);
       for (ClassElement check in typeChecks[cls]) {
-        buffer.add('$holder.${namer.operatorIs(check)}$_=${_}true$N');
+        buffer.write('$holder.${namer.operatorIs(check)}$_=${_}true$N');
         String body = rti.getSupertypeSubstitution(cls, check);
         if (body != null) {
-          buffer.add('$holder.${namer.substitutionName(check)}$_=${_}$body$N');
+          buffer.write('$holder.${namer.substitutionName(check)}$_=${_}$body$N');
         }
       };
     }
   }
 
   void visitNativeMixins(ClassElement classElement,
                          void visit(MixinApplicationElement mixinApplication)) {
     if (!classElement.isNative()) return;
     // Use recursion to make sure to visit the superclasses before the
     // subclasses. Once we start keeping track of the emitted fields
@@ skipping 289 matching lines @@
 
     emitClassConstructor(classElement, builder);
     emitSuper(superName, builder);
     emitClassFields(classElement, builder,
                     superClass: superName, classIsNative: false);
     emitClassGettersSetters(classElement, builder);
     emitInstanceMembers(classElement, builder);
 
     jsAst.Expression init =
         js[classesCollector][className].assign(builder.toObjectInitializer());
-    buffer.add(jsAst.prettyPrint(init, compiler));
-    buffer.add('$N$n');
+    buffer.write(jsAst.prettyPrint(init, compiler));
+    buffer.write('$N$n');
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
   int _selectorRank(Selector selector) {
     int arity = selector.argumentCount * 3;
     if (selector.isGetter()) return arity + 2;
     if (selector.isSetter()) return arity + 1;
     return arity;
   }
@@ skipping 183 matching lines @@
     // The closure class could have become necessary because of the generation
     // of stubs.
     ClassElement closureClass = compiler.closureClass;
     if (needsClosureClass && !instantiatedClasses.contains(closureClass)) {
       generateClass(closureClass, bufferForElement(closureClass, buffer));
     }
   }
 
   void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
-      buffer.add('$finishClassesName($classesCollector,'
-                 '$_$isolateProperties,'
-                 '${_}null)$N');
+      buffer.write('$finishClassesName($classesCollector,'
+                   '$_$isolateProperties,'
+                   '${_}null)$N');
 
       // Reset the map.
-      buffer.add("$classesCollector$_=${_}null$N$n");
+      buffer.write("$classesCollector$_=${_}null$N$n");
     }
   }
 
   void emitStaticFunction(CodeBuffer buffer,
                           String name,
                           jsAst.Expression functionExpression) {
     jsAst.Expression assignment =
         js[isolateProperties][name].assign(functionExpression);
-    buffer.add(jsAst.prettyPrint(assignment, compiler));
-    buffer.add('$N$n');
+    buffer.write(jsAst.prettyPrint(assignment, compiler));
+    buffer.write('$N$n');
   }
 
   void emitStaticFunctions(CodeBuffer eagerBuffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         backend.generatedBailoutCode.keys
@@ skipping 30 matching lines @@
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
                                        element);
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
-      buffer.add("$fieldAccess.$invocationName$_=$_$fieldAccess$N");
+      buffer.write("$fieldAccess.$invocationName$_=$_$fieldAccess$N");
 
       addParameterStubs(callElement, (String name, jsAst.Expression value) {
         jsAst.Expression assignment =
             js[isolateProperties][staticName][name].assign(value);
-        buffer.add(
-            jsAst.prettyPrint(assignment.toStatement(), compiler));
-        buffer.add('$N');
+        buffer.write(jsAst.prettyPrint(assignment.toStatement(), compiler));
+        buffer.write('$N');
       });
 
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
-      buffer.add('$fieldAccess.$fieldName$_=$_"$staticName"$N');
+      buffer.write('$fieldAccess.$fieldName$_=$_"$staticName"$N');
       getTypedefChecksOn(element.computeType(compiler)).forEach(
         (Element typedef) {
           String operator = namer.operatorIs(typedef);
-          buffer.add('$fieldAccess.$operator$_=${_}true$N');
+          buffer.write('$fieldAccess.$operator$_=${_}true$N');
         }
       );
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
                                    String superName,
                                    List<String> fieldNames,
                                    ClassBuilder builder) {
     builder.addProperty('',
@@ skipping 219 matching lines @@
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         jsAst.Expression init =
           js[isolateProperties][namer.getName(element)].assign(
               constantEmitter.referenceInInitializationContext(initialValue));
-        buffer.add(jsAst.prettyPrint(init, compiler));
-        buffer.add('$N');
+        buffer.write(jsAst.prettyPrint(init, compiler));
+        buffer.write('$N');
       });
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
@@ skipping 10 matching lines @@
         arguments.add(js[isolateProperties]);
         arguments.add(js.string(element.name.slowToString()));
         arguments.add(js.string(namer.getName(element)));
         arguments.add(js.string(namer.getLazyInitializerName(element)));
         arguments.add(code);
         jsAst.Expression getter = buildLazyInitializedGetter(element);
         if (getter != null) {
           arguments.add(getter);
         }
         jsAst.Expression init = js[lazyInitializerName](arguments);
-        buffer.add(jsAst.prettyPrint(init, compiler));
-        buffer.add("$N");
+        buffer.write(jsAst.prettyPrint(init, compiler));
+        buffer.write("$N");
       }
     }
   }
 
   jsAst.Expression buildLazyInitializedGetter(VariableElement element) {
     // Nothing to do, the 'lazy' function will create the getter.
     return null;
   }
 
   void emitCompileTimeConstants(CodeBuffer eagerBuffer) {
@@ skipping 12 matching lines @@
       // share the ones that take up too much space (like some strings).
       if (name == null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
         emitMakeConstantList(eagerBuffer);
       }
       CodeBuffer buffer =
           bufferForElement(constant.computeType(compiler).element, eagerBuffer);
       jsAst.Expression init = js[isolateProperties][name].assign(
           constantInitializerExpression(constant));
-      buffer.add(jsAst.prettyPrint(init, compiler));
-      buffer.add('$N');
+      buffer.write(jsAst.prettyPrint(init, compiler));
+      buffer.write('$N');
     }
   }
 
   void emitMakeConstantList(CodeBuffer buffer) {
-    buffer.add(namer.isolateName);
-    buffer.add(r'''.makeConstantList = function(list) {
+    buffer.write(namer.isolateName);
+    buffer.write(r'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 154 matching lines @@
   String buildIsolateSetup(CodeBuffer buffer,
                            Element appMain,
                            Element isolateMain) {
     String mainAccess = "${namer.isolateAccess(appMain)}";
     String currentIsolate = "${namer.CURRENT_ISOLATE}";
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     if (!compiler.codegenWorld.staticFunctionsNeedingGetter.contains(appMain)) {
       Selector selector = new Selector.callClosure(0);
       String invocationName = namer.invocationName(selector);
-      buffer.add("$mainAccess.$invocationName = $mainAccess$N");
+      buffer.write("$mainAccess.$invocationName = $mainAccess$N");
     }
     return "${namer.isolateAccess(isolateMain)}($mainAccess)";
   }
 
   emitMain(CodeBuffer buffer) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainApp.find(Compiler.MAIN);
     String mainCall = null;
     if (compiler.hasIsolateSupport()) {
       Element isolateMain =
         compiler.isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE);
       mainCall = buildIsolateSetup(buffer, main, isolateMain);
     } else {
       mainCall = '${namer.isolateAccess(main)}()';
     }
     addComment('BEGIN invoke [main].', buffer);
-    buffer.add("""
+    buffer.write("""
 if (typeof document !== "undefined" && document.readyState !== "complete") {
   document.addEventListener("readystatechange", function () {
     if (document.readyState == "complete") {
       if (typeof dartMainRunner === "function") {
         dartMainRunner(function() { ${mainCall}; });
       } else {
         ${mainCall};
       }
     }
   }, false);
@@ skipping 112 matching lines @@
     if (hasBool) {
       block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
       block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
     block.statements.add(js.return_(receiver));
 
-    buffer.add(jsAst.prettyPrint(
+    buffer.write(jsAst.prettyPrint(
         js[isolateProperties][key].assign(js.fun(['receiver'], block)),
         compiler));
-    buffer.add(N);
+    buffer.write(N);
   }
 
   /**
    * Emit all versions of the [:getInterceptor:] method.
    */
   void emitGetInterceptorMethods(CodeBuffer buffer) {
     var specializedGetInterceptors = backend.specializedGetInterceptors;
     for (String name in specializedGetInterceptors.keys.toList()..sort()) {
       Collection<ClassElement> classes = specializedGetInterceptors[name];
       emitGetInterceptorMethod(buffer, name, classes);
@@ skipping 252 matching lines @@
       String invocationName = backend.namer.invocationName(selector);
       body.add(js.return_(
           js[isolateProperties][getInterceptorName]('receiver')[invocationName](
               arguments)));
 
       jsAst.Fun function = js.fun(parameters, body);
 
       jsAst.PropertyAccess property =
           js[isolateProperties][name];
 
-      buffer.add(jsAst.prettyPrint(property.assign(function), compiler));
-      buffer.add(N);
+      buffer.write(jsAst.prettyPrint(property.assign(function), compiler));
+      buffer.write(N);
     }
   }
 
   /**
    * If [:invokeOn:] has been compiled, emit all the possible selector names
    * that are intercepted into the [:interceptedNames:] top-level
    * variable. The implementation of [:invokeOn:] will use it to
    * determine whether it should call the method with an extra
    * parameter.
    */
   void emitInterceptedNames(CodeBuffer buffer) {
     if (!compiler.enabledInvokeOn) return;
     String name = backend.namer.getName(backend.interceptedNames);
     jsAst.PropertyAccess property = js[isolateProperties][name];
 
     int index = 0;
     List<jsAst.ArrayElement> elements = backend.usedInterceptors.map(
       (Selector selector) {
         jsAst.Literal str = js.string(namer.invocationName(selector));
         return new jsAst.ArrayElement(index++, str);
       }).toList();
     jsAst.ArrayInitializer array = new jsAst.ArrayInitializer(
         backend.usedInterceptors.length,
         elements);
 
-    buffer.add(jsAst.prettyPrint(property.assign(array), compiler));
-    buffer.add(N);
+    buffer.write(jsAst.prettyPrint(property.assign(array), compiler));
+    buffer.write(N);
   }
 
   void emitInitFunction(CodeBuffer buffer) {
     jsAst.Fun fun = js.fun([], [
       js['$isolateProperties = {}'],
     ]
     ..addAll(buildDefineClassAndFinishClassFunctionsIfNecessary())
     ..addAll(buildLazyInitializerFunctionIfNecessary())
     ..addAll(buildFinishIsolateConstructor())
     );
     jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('init'), fun);
-    buffer.add(jsAst.prettyPrint(decl, compiler).getText());
+    buffer.write(jsAst.prettyPrint(decl, compiler).getText());
   }
 
   String assembleProgram() {
     measure(() {
       computeNeededClasses();
 
       // Compute the required type checks to know which classes need a
       // 'is$' method.
       computeRequiredTypeChecks();
 
@@ skipping 105 matching lines @@
 
   CodeBuffer bufferForElement(Element element, CodeBuffer eagerBuffer) {
     if (!isDeferred(element)) return eagerBuffer;
     emitDeferredPreambleWhenEmpty(deferredBuffer);
     return deferredBuffer;
   }
 
   void emitDeferredCode(CodeBuffer buffer) {
     if (buffer.isEmpty) return;
 
-    buffer.add(n);
+    buffer.write(n);
 
-    buffer.add('${namer.CURRENT_ISOLATE}$_=${_}old${namer.CURRENT_ISOLATE}$N');
+    buffer.write(
+        '${namer.CURRENT_ISOLATE}$_=${_}old${namer.CURRENT_ISOLATE}$N');
 
     String code = buffer.getText();
     compiler.outputProvider('part', 'js')
       ..add(code)
       ..close();
     outputSourceMap(buffer, compiler.assembledCode, 'part');
   }
 
   void emitDeferredPreambleWhenEmpty(CodeBuffer buffer) {
     if (!buffer.isEmpty) return;
 
-    buffer.add(GENERATED_BY);
+    buffer.write(GENERATED_BY);
 
-    buffer.add('var old${namer.CURRENT_ISOLATE}$_='
-               '$_${namer.CURRENT_ISOLATE}$N');
+    buffer.write('var old${namer.CURRENT_ISOLATE}$_='
+                 '$_${namer.CURRENT_ISOLATE}$N');
 
     // TODO(ahe): This defines a lot of properties on the
     // Isolate.prototype object.  We know this will turn it into a
     // slow object in V8, so instead we should do something similar to
     // Isolate.$finishIsolateConstructor.
-    buffer.add('${namer.CURRENT_ISOLATE}$_='
-               '$_${namer.isolateName}.prototype$N$n');
+    buffer.write('${namer.CURRENT_ISOLATE}$_='
+                 '$_${namer.isolateName}.prototype$N$n');
   }
 
   String buildSourceMap(CodeBuffer buffer, SourceFile compiledFile) {
     SourceMapBuilder sourceMapBuilder = new SourceMapBuilder();
     buffer.forEachSourceLocation(sourceMapBuilder.addMapping);
     return sourceMapBuilder.build(compiledFile);
   }
 
   void outputSourceMap(CodeBuffer buffer, String code, String name) {
     if (!generateSourceMap) return;
@@ skipping 21 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;