Emit to StreamCodeOutput instead of CodeBuffer.

pkg/compiler/lib/src/js_backend/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.
 
 part of js_backend;
 
 class NativeEmitter {
 
   final Map<Element, ClassBuilder> cachedBuilders;
 
   final CodeEmitterTask emitterTask;
-  CodeBuffer nativeBuffer;
 
   // Native classes found in the application.
   Set<ClassElement> nativeClasses = new Set<ClassElement>();
 
   // Caches the native subtypes of a native class.
   Map<ClassElement, List<ClassElement>> subtypes;
 
   // Caches the direct native subtypes of a native class.
   Map<ClassElement, List<ClassElement>> directSubtypes;
 
   // Caches the methods that have a native body.
   Set<FunctionElement> nativeMethods;
 
   // Do we need the native emitter to take care of handling
   // noSuchMethod for us? This flag is set to true in the emitter if
   // it finds any native class that needs noSuchMethod handling.
   bool handleNoSuchMethod = false;
 
   NativeEmitter(CodeEmitterTask emitterTask)
       : this.emitterTask = emitterTask,
         subtypes = new Map<ClassElement, List<ClassElement>>(),
         directSubtypes = new Map<ClassElement, List<ClassElement>>(),
         nativeMethods = new Set<FunctionElement>(),
-        nativeBuffer = new CodeBuffer(),
         cachedBuilders = emitterTask.compiler.cacheStrategy.newMap();
 
   Compiler get compiler => emitterTask.compiler;
   JavaScriptBackend get backend => compiler.backend;
 
   jsAst.Expression get defPropFunction {
     Element element = backend.findHelper('defineProperty');
     return emitterTask.staticFunctionAccess(element);
   }
 
   /**
-   * Writes the class definitions for the interceptors to [mainBuffer].
    * Writes code to associate dispatch tags with interceptors to [nativeBuffer].
    *
    * The interceptors are filtered to avoid emitting trivial interceptors.  For
    * example, if the program contains no code that can distinguish between the
    * numerous subclasses of `Element` then we can pretend that `Element` is a
    * leaf class, and all instances of subclasses of `Element` are instances of
    * `Element`.
    *
    * There is also a performance benefit (in addition to the obvious code size
    * benefit), due to how [getNativeInterceptor] works.  Finding the interceptor
    * of a leaf class in the hierarchy is more efficient that a non-leaf, so it
    * improves performance when more classes can be treated as leaves.
    *
    * [classes] contains native classes, mixin applications, and user subclasses
    * of native classes.  ONLY the native classes are generated here.  [classes]
    * is sorted in desired output order.
    *
    * [additionalProperties] is used to collect properties that are pushed up
    * from the above optimizations onto a non-native class, e.g, `Interceptor`.
    */
   void generateNativeClasses(
       List<ClassElement> classes,
-      CodeBuffer mainBuffer,
       Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties) {
     // Compute a pre-order traversal of the subclass forest.  We actually want a
     // post-order traversal but it is easier to compute the pre-order and use it
     // in reverse.
 
     List<ClassElement> preOrder = <ClassElement>[];
     Set<ClassElement> seen = new Set<ClassElement>();
     seen..add(compiler.objectClass)
         ..add(backend.jsInterceptorClass);
     void walk(ClassElement element) {
@@ skipping 353 matching lines @@
     // used.  We should also use an interceptor if the check can't be satisfied
     // by a native class in case we get a native instance that tries to spoof
     // the type info.  i.e the criteria for whether or not to use an interceptor
     // is whether the receiver can be native, not the type of the test.
     if (element == null || !element.isClass) return false;
     ClassElement cls = element;
     if (Elements.isNativeOrExtendsNative(cls)) return true;
     return isSupertypeOfNativeClass(element);
   }
 
-  void assembleCode(CodeBuffer targetBuffer) {
+  void assembleCode(CodeOutput targetOutput) {
     List<jsAst.Property> objectProperties = <jsAst.Property>[];
 
     jsAst.Property addProperty(String name, jsAst.Expression value) {
       jsAst.Property prop = new jsAst.Property(js.string(name), value);
       objectProperties.add(prop);
       return prop;
     }
 
     if (!nativeClasses.isEmpty) {
       // If the native emitter has been asked to take care of the
       // noSuchMethod handlers, we do that now.
       if (handleNoSuchMethod) {
         emitterTask.oldEmitter.nsmEmitter.emitNoSuchMethodHandlers(addProperty);
       }
     }
 
     // If we have any properties to add to Object.prototype, we run
     // through them and add them using defineProperty.
     if (!objectProperties.isEmpty) {
       jsAst.Expression init = js(r'''
           (function(table) {
             for(var key in table)
               #(Object.prototype, key, table[key]);
            })(#)''',
           [ defPropFunction,
             new jsAst.ObjectInitializer(objectProperties)]);
 
-      if (emitterTask.compiler.enableMinification) targetBuffer.write(';');
-      targetBuffer.write(jsAst.prettyPrint(
+      if (emitterTask.compiler.enableMinification) {
+        targetOutput.add(';');
+      }
+      targetOutput.addBuffer(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
-      targetBuffer.write('\n');
+      targetOutput.add('\n');
     }
 
-    targetBuffer.write(nativeBuffer);
-    targetBuffer.write('\n');
+    targetOutput.add('\n');
   }
 }