Introduce CodeBuffer as StringBuffer replacement in compiler.

lib/compiler/implementation/native_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.
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
-  StringBuffer nativeBuffer;
+  CodeBuffer nativeBuffer;
 
   // Classes that participate in dynamic dispatch. These are the
   // classes that contain used members.
   Set<ClassElement> classesWithDynamicDispatch;
 
   // Native classes found in the application.
   Set<ClassElement> nativeClasses;
 
   // Caches the native subtypes of a native class.
   Map<ClassElement, List<ClassElement>> subtypes;
@@ skipping 14 matching lines @@
   Map<FunctionElement, String> redirectingMethods;
 
   NativeEmitter(this.emitter)
       : classesWithDynamicDispatch = new Set<ClassElement>(),
         nativeClasses = new Set<ClassElement>(),
         subtypes = new Map<ClassElement, List<ClassElement>>(),
         directSubtypes = new Map<ClassElement, List<ClassElement>>(),
         overriddenMethods = new Set<FunctionElement>(),
         nativeMethods = new Set<FunctionElement>(),
         redirectingMethods = new Map<FunctionElement, String>(),
-        nativeBuffer = new StringBuffer();
+        nativeBuffer = new CodeBuffer();
 
   Compiler get compiler() => emitter.compiler;
 
   void addRedirectingMethod(FunctionElement element, String name) {
     redirectingMethods[element] = name;
   }
 
   String get dynamicName() {
     Element element = compiler.findHelper(
         const SourceString('dynamicFunction'));
@@ skipping 42 matching lines @@
 
   void generateNativeLiteral(ClassElement classElement) {
     String quotedNative = classElement.nativeName.slowToString();
     String nativeCode = quotedNative.substring(2, quotedNative.length - 1);
     String className = compiler.namer.getName(classElement);
     nativeBuffer.add(className);
     nativeBuffer.add(' = ');
     nativeBuffer.add(nativeCode);
     nativeBuffer.add(';\n');
 
-    void defineInstanceMember(String name,
-                              String value,
-                              [List<SourceMappingEntry> sourceMappings]) {
+    void defineInstanceMember(String name, CodeBuffer value) {
       nativeBuffer.add("$className.$name = $value;\n");
     }
 
     for (Element member in classElement.members) {
       if (member.isInstanceMember()) {
         emitter.addInstanceMember(member, defineInstanceMember);
       }
     }
   }
 
@@ skipping 20 matching lines @@
 
     assert(classElement.backendMembers.isEmpty());
     String quotedName = classElement.nativeName.slowToString();
     if (isNativeLiteral(quotedName)) {
       generateNativeLiteral(classElement);
       // The native literal kind needs to be dealt with specially when
       // generating code for it.
       return;
     }
 
-    StringBuffer fieldBuffer = new StringBuffer();
+    CodeBuffer fieldBuffer = new CodeBuffer();
     emitter.emitClassFields(classElement, fieldBuffer);
 
-    StringBuffer methodBuffer = new StringBuffer();
+    CodeBuffer methodBuffer = new CodeBuffer();
     emitter.emitInstanceMembers(classElement, methodBuffer, false);
 
     if (methodBuffer.isEmpty() && fieldBuffer.isEmpty()) return;
 
     String nativeName = toNativeName(classElement);
     nativeBuffer.add("$defineNativeClassName('$nativeName', [");
     nativeBuffer.add(fieldBuffer);
     nativeBuffer.add('], {');
     nativeBuffer.add(methodBuffer);
     nativeBuffer.add('\n});\n\n');
 
     classesWithDynamicDispatch.add(classElement);
   }
 
   List<ClassElement> getDirectSubclasses(ClassElement cls) {
     List<ClassElement> result = directSubtypes[cls];
     return result === null ? const<ClassElement>[] : result;
   }
 
-  void potentiallyConvertDartClosuresToJs(StringBuffer code,
+  void potentiallyConvertDartClosuresToJs(CodeBuffer code,
                                           FunctionElement member,
                                           List<String> argumentsBuffer) {
     FunctionSignature parameters = member.computeSignature(compiler);
     Element converter =
         compiler.findHelper(const SourceString('convertDartClosureToJS'));
     String closureConverter = compiler.namer.isolateAccess(converter);
     parameters.forEachParameter((Element parameter) {
       String name = parameter.name.slowToString();
       // If [name] is not in [argumentsBuffer], then the parameter is
       // an optional parameter that was not provided for that stub.
       if (argumentsBuffer.indexOf(name) == -1) return;
       Type type = parameter.computeType(compiler);
       if (type is FunctionType) {
         int arity = type.computeArity();
         code.add('  $name = $closureConverter($name, $arity);\n');
       }
     });
   }
 
   String generateParameterStub(Element member,
                                String invocationName,
                                String stubParameters,
                                List<String> argumentsBuffer,
                                int indexOfLastOptionalArgumentInParameters,
-                               StringBuffer buffer) {
+                               CodeBuffer buffer) {
     // The target JS function may check arguments.length so we need to
     // make sure not to pass any unspecified optional arguments to it.
     // For example, for the following Dart method:
     //   foo([x, y, z]);
     // The call:
     //   foo(y: 1)
     // must be turned into a JS call to:
     //   foo(null, y).
 
     List<String> nativeArgumentsBuffer = argumentsBuffer.getRange(
         0, indexOfLastOptionalArgumentInParameters + 1);
 
     ClassElement classElement = member.enclosingElement;
     String nativeName = classElement.nativeName.slowToString();
     String nativeArguments = Strings.join(nativeArgumentsBuffer, ",");
 
-    StringBuffer code = new StringBuffer();
+    CodeBuffer code = new CodeBuffer();
     potentiallyConvertDartClosuresToJs(code, member, argumentsBuffer);
 
     if (!nativeMethods.contains(member)) {
       // When calling a method that has a native body, we call it
       // with our calling conventions.
       String arguments = Strings.join(argumentsBuffer, ",");
       code.add('  return this.${compiler.namer.getName(member)}($arguments)');
     } else {
       // When calling a JS method, we call it with the native name.
       String name = redirectingMethods[member];
@@ skipping 142 matching lines @@
     return subtypes[element] !== null;
   }
 
   bool requiresNativeIsCheck(Element element) {
     if (!element.isClass()) return false;
     ClassElement cls = element;
     if (cls.isNative()) return true;
     return isSupertypeOfNativeClass(element);
   }
 
-  void emitIsChecks(StringBuffer checkBuffer) {
+  void emitIsChecks(CodeBuffer checkBuffer) {
     for (Element type in compiler.codegenWorld.isChecks) {
       if (!requiresNativeIsCheck(type)) continue;
       String name = compiler.namer.operatorIs(type);
       checkBuffer.add("$defPropName(Object.prototype, '$name', ");
       checkBuffer.add('function() { return false; });\n');
     }
   }
 
-  void assembleCode(StringBuffer targetBuffer) {
+  void assembleCode(CodeBuffer targetBuffer) {
     if (nativeClasses.isEmpty()) return;
     emitDynamicDispatchMetadata();
 
     // Because of native classes, we have to generate some is checks
     // by calling a method, instead of accessing a property. So we
     // attach to the JS Object prototype these methods that return
     // false, and will be overridden by subclasses when they have to
     // return true.
-    StringBuffer objectProperties = new StringBuffer();
+    CodeBuffer objectProperties = new CodeBuffer();
     emitIsChecks(objectProperties);
 
     // In order to have the toString method on every native class,
     // we must patch the JS Object prototype with a helper method.
     String toStringName = compiler.namer.instanceMethodName(
         null, const SourceString('toString'), 0);
     objectProperties.add("$defPropName(Object.prototype, '$toStringName', ");
     objectProperties.add(
         'function() { return $toStringHelperName(this); });\n');
 
     targetBuffer.add('$defineNativeClassName = $defineNativeClassFunction;\n');
     targetBuffer.add('$objectProperties$nativeBuffer\n');
   }
 }