Emit to StreamCodeOutput instead of CodeBuffer.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   final TypeTestEmitter typeTestEmitter = new TypeTestEmitter();
   final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
   final MetadataEmitter metadataEmitter = new MetadataEmitter();
 
+  // TODO(johnniwinther): Wrap these fields in a caching strategy.
   final Set<ConstantValue> cachedEmittedConstants;
   final CodeBuffer cachedEmittedConstantsBuffer = new CodeBuffer();
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
   bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter get nativeEmitter => task.nativeEmitter;
   TypeTestRegistry get typeTestRegistry => task.typeTestRegistry;
 
   // The full code that is written to each hunk part-file.
-  Map<OutputUnit, CodeBuffer> outputBuffers = new Map<OutputUnit, CodeBuffer>();
-  final CodeBuffer deferredConstants = new CodeBuffer();
+  Map<OutputUnit, CodeOutput> outputBuffers = new Map<OutputUnit, CodeOutput>();
 
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
   Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
   List<ClassElement> get nativeClasses => task.nativeClasses;
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
 
   final Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties =
       new Map<ClassElement, Map<String, jsAst.Expression>>();
 
   List<TypedefElement> get typedefsNeededForReflection =>
       task.typedefsNeededForReflection;
 
   JavaScriptBackend get backend => compiler.backend;
   TypeVariableHandler get typeVariableHandler => backend.typeVariableHandler;
 
   String get _ => space;
   String get space => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
 
-  CodeBuffer getBuffer(OutputUnit outputUnit) {
-    return outputBuffers.putIfAbsent(outputUnit, () => new CodeBuffer());
-  }
-
-  CodeBuffer get mainBuffer {
-    return getBuffer(compiler.deferredLoadTask.mainOutputUnit);
-  }
-
   /**
    * List of expressions and statements that will be included in the
    * precompiled function.
    *
    * To save space, dart2js normally generates constructors and accessors
    * dynamically. This doesn't work in CSP mode, so dart2js emits them directly
    * when in CSP mode.
    */
   Map<OutputUnit, List<jsAst.Node>> _cspPrecompiledFunctions =
       new Map<OutputUnit, List<jsAst.Node>>();
@@ skipping 44 matching lines @@
         () => new List<jsAst.Expression>());
   }
 
   /// Erases the precompiled information for csp mode for all output units.
   /// Used by the incremental compiler.
   void clearCspPrecompiledNodes() {
     _cspPrecompiledFunctions.clear();
     _cspPrecompiledConstructorNames.clear();
   }
 
-  void addComment(String comment, CodeBuffer buffer) {
-    buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
+  void addComment(String comment, CodeOutput output) {
+    output.addBuffer(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
   @override
   jsAst.Expression constantReference(ConstantValue value) {
     return constantEmitter.reference(value);
   }
 
   jsAst.Expression constantInitializerExpression(ConstantValue value) {
     return constantEmitter.initializationExpression(value);
   }
@@ skipping 175 matching lines @@
     //   this.x = t - v;
     //  },
     // });
 
     bool hasIsolateSupport = compiler.hasIsolateSupport;
     String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
 
     jsAst.Expression defineClass = js('''
         function(name, fields) {
           var accessors = [];
-    
+
           var str = "function " + name + "(";
           var body = "";
           if (#hasIsolateSupport) { var fieldNames = ""; }
-    
+
           for (var i = 0; i < fields.length; i++) {
             if(i != 0) str += ", ";
-    
+
             var field = generateAccessor(fields[i], accessors, name);
             if (#hasIsolateSupport) { fieldNames += "'" + field + "',"; }
             var parameter = "parameter_" + field;
             str += parameter;
             body += ("this." + field + " = " + parameter + ";\\n");
           }
           str += ") {\\n" + body + "}\\n";
           str += name + ".builtin\$cls=\\"" + name + "\\";\\n";
           str += "\$desc=\$collectedClasses." + name + ";\\n";
           str += "if(\$desc instanceof Array) \$desc = \$desc[1];\\n";
           str += name + ".prototype = \$desc;\\n";
           if (typeof defineClass.name != "string") {
             str += name + ".name=\\"" + name + "\\";\\n";
           }
           if (#hasIsolateSupport) {
             str += name + ".$fieldNamesProperty=[" + fieldNames + "];\\n";
           }
           str += accessors.join("");
-    
+
           return str;
         }''', { 'hasIsolateSupport': hasIsolateSupport });
 
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction.
     List result = <jsAst.Node>[
         generateAccessorFunction,
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
 
@@ skipping 199 matching lines @@
       }
     }''', {'finishedClassesAccess': finishedClassesAccess,
            'needsMixinSupport': needsMixinSupport,
            'hasNativeClasses': nativeClasses.isNotEmpty,
            'nativeSuperclassTagName': embeddedNames.NATIVE_SUPERCLASS_TAG_NAME,
            'interceptorsByTagAccess': interceptorsByTagAccess,
            'leafTagsAccess': leafTagsAccess,
            'allowNativesSubclassing': true});
   }
 
-  void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
+  void emitFinishIsolateConstructorInvocation(CodeOutput output) {
     String isolate = namer.isolateName;
-    buffer.write("$isolate = $finishIsolateConstructorName($isolate)$N");
+    output.add("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
     if (!element.isClass) return false;
     return (element == compiler.intClass ||
             element == compiler.doubleClass ||
             element == compiler.numClass ||
             element == compiler.stringClass ||
             element == compiler.boolClass ||
@@ skipping 159 matching lines @@
   }
 
   void emitStaticFunctions(List<Element> staticFunctions) {
     for (Element element in staticFunctions) {
       ClassBuilder builder = new ClassBuilder(element, namer);
       containerBuilder.addMember(element, builder);
       getElementDescriptor(element).properties.addAll(builder.properties);
     }
   }
 
-  void emitStaticNonFinalFieldInitializations(CodeBuffer buffer,
+  void emitStaticNonFinalFieldInitializations(CodeOutput output,
                                               OutputUnit outputUnit) {
     JavaScriptConstantCompiler handler = backend.constants;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
       // `mapTypeToInterceptor` is handled in [emitMapTypeToInterceptor].
       if (element == backend.mapTypeToInterceptor) continue;
       compiler.withCurrentElement(element, () {
         jsAst.Expression initialValue;
         if (outputUnit !=
             compiler.deferredLoadTask.outputUnitForElement(element)) {
           if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
             // In the main output-unit we output a stub initializer for deferred
             // variables, such that `isolateProperties` stays a fast object.
             initialValue = jsAst.number(0);
           } else {
             // Don't output stubs outside the main output file.
             return;
           }
         } else {
           initialValue = constantEmitter.referenceInInitializationContext(
               handler.getInitialValueFor(element).value);
 
         }
         jsAst.Expression init =
           js('$isolateProperties.# = #',
               [namer.getNameOfGlobalField(element), initialValue]);
-        buffer.write(jsAst.prettyPrint(init, compiler,
-                                       monitor: compiler.dumpInfoTask));
-        buffer.write('$N');
+        output.addBuffer(jsAst.prettyPrint(init, compiler,
+                                           monitor: compiler.dumpInfoTask));
+        output.add('$N');
       });
     }
   }
 
-  void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
+  void emitLazilyInitializedStaticFields(CodeOutput output) {
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
       for (VariableElement element in Elements.sortedByPosition(lazyFields)) {
         jsAst.Expression init =
             buildLazilyInitializedStaticField(element, isolateProperties);
         if (init == null) continue;
-        buffer.write(
+        output.addBuffer(
             jsAst.prettyPrint(init, compiler, monitor: compiler.dumpInfoTask));
-        buffer.write("$N");
+        output.add("$N");
       }
     }
   }
 
   jsAst.Expression buildLazilyInitializedStaticField(
       VariableElement element, String isolateProperties) {
     jsAst.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
@@ skipping 38 matching lines @@
 
     // Sorting by the long name clusters constants with the same constructor
     // which compresses a tiny bit better.
     int r = namer.constantLongName(a).compareTo(namer.constantLongName(b));
     if (r != 0) return r;
     // Resolve collisions in the long name by using the constant name (i.e. JS
     // name) which is unique.
     return namer.constantName(a).compareTo(namer.constantName(b));
   }
 
-  void emitCompileTimeConstants(CodeBuffer buffer, OutputUnit outputUnit) {
+  void emitCompileTimeConstants(CodeOutput output, OutputUnit outputUnit) {
     List<ConstantValue> constants = outputConstantLists[outputUnit];
     if (constants == null) return;
-    bool isMainBuffer = buffer == mainBuffer;
-    if (compiler.hasIncrementalSupport && isMainBuffer) {
-      buffer = cachedEmittedConstantsBuffer;
+    CodeOutput constantOutput = output;
+    if (compiler.hasIncrementalSupport && outputUnit.isMainOutput) {
+      constantOutput = cachedEmittedConstantsBuffer;
     }
     for (ConstantValue constant in constants) {
-      if (compiler.hasIncrementalSupport && isMainBuffer) {
+      if (compiler.hasIncrementalSupport && outputUnit.isMainOutput) {
         if (cachedEmittedConstants.contains(constant)) continue;
         cachedEmittedConstants.add(constant);
       }
       jsAst.Expression init = buildConstantInitializer(constant);
-      buffer.write(jsAst.prettyPrint(init, compiler,
-                                     monitor: compiler.dumpInfoTask));
-      buffer.write('$N');
+      constantOutput.addBuffer(jsAst.prettyPrint(init, compiler,
+                                         monitor: compiler.dumpInfoTask));
+      constantOutput.add('$N');
     }
-    if (compiler.hasIncrementalSupport && isMainBuffer) {
-      mainBuffer.write(cachedEmittedConstantsBuffer);
+    if (compiler.hasIncrementalSupport && outputUnit.isMainOutput) {
+      output.addBuffer(constantOutput);
     }
   }
 
   jsAst.Expression buildConstantInitializer(ConstantValue constant) {
     String name = namer.constantName(constant);
     return js('#.# = #',
               [namer.globalObjectForConstant(constant), name,
                constantInitializerExpression(constant)]);
   }
 
   jsAst.Template get makeConstantListTemplate {
     // TODO(floitsch): there is no harm in caching the template.
     return jsAst.js.uncachedExpressionTemplate(
         '${namer.isolateName}.$makeConstListProperty(#)');
   }
 
-  void emitMakeConstantList(CodeBuffer buffer) {
-    buffer.write(
+  void emitMakeConstantList(CodeOutput output) {
+    output.addBuffer(
         jsAst.prettyPrint(
             // Functions are stored in the hidden class and not as properties in
             // the object. We never actually look at the value, but only want
             // to know if the property exists.
             js.statement(r'''#.# = function(list) {
                                      list.immutable$list = Array;
                                      list.fixed$length = Array;
                                      return list;
                                    }''',
                          [namer.isolateName, makeConstListProperty]),
             compiler, monitor: compiler.dumpInfoTask));
-    buffer.write(N);
+    output.add(N);
   }
 
   /// Returns the code equivalent to:
   ///   `function(args) { $.startRootIsolate(X.main$closure(), args); }`
   jsAst.Expression buildIsolateSetupClosure(Element appMain,
                                             Element isolateMain) {
     jsAst.Expression mainAccess = isolateStaticClosureAccess(appMain);
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
     return js('function(a){ #(#, a); }',
@@ skipping 52 matching lines @@
     return js('# = #("dispatch_record")',
         [dispatchPropertyNameAccess,
          getIsolateTagAccess]);
   }
 
   String generateIsolateTagRoot() {
     // TODO(sra): MD5 of contributing source code or URIs?
     return 'ZxYxX';
   }
 
-  emitMain(CodeBuffer buffer) {
+  emitMain(CodeOutput output) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainFunction;
     jsAst.Expression mainCallClosure = null;
     if (compiler.hasIsolateSupport) {
       Element isolateMain =
         backend.isolateHelperLibrary.find(JavaScriptBackend.START_ROOT_ISOLATE);
       mainCallClosure = buildIsolateSetupClosure(main, isolateMain);
     } else if (compiler.hasIncrementalSupport) {
       mainCallClosure = js(
           'function() { return #(); }',
           backend.emitter.staticFunctionAccess(main));
     } else {
       mainCallClosure = backend.emitter.staticFunctionAccess(main);
     }
 
     if (backend.needToInitializeIsolateAffinityTag) {
-      buffer.write(
+      output.addBuffer(
           jsAst.prettyPrint(generateIsolateAffinityTagInitialization(),
                             compiler, monitor: compiler.dumpInfoTask));
-      buffer.write(N);
+      output.add(N);
     }
     if (backend.needToInitializeDispatchProperty) {
       assert(backend.needToInitializeIsolateAffinityTag);
-      buffer.write(
+      output.addBuffer(
           jsAst.prettyPrint(generateDispatchPropertyNameInitialization(),
               compiler, monitor: compiler.dumpInfoTask));
-      buffer.write(N);
+      output.add(N);
     }
 
     jsAst.Expression currentScriptAccess =
         generateEmbeddedGlobalAccess(embeddedNames.CURRENT_SCRIPT);
 
-    addComment('BEGIN invoke [main].', buffer);
+    addComment('BEGIN invoke [main].', output);
     // This code finds the currently executing script by listening to the
     // onload event of all script tags and getting the first script which
     // finishes. Since onload is called immediately after execution this should
     // not substantially change execution order.
     jsAst.Statement invokeMain = js.statement('''
 (function (callback) {
   if (typeof document === "undefined") {
     callback(null);
     return;
   }
@@ skipping 16 matching lines @@
   #currentScript = currentScript;
 
   if (typeof dartMainRunner === "function") {
     dartMainRunner(#mainCallClosure, []);
   } else {
     #mainCallClosure([]);
   }
 })''', {'currentScript': currentScriptAccess,
         'mainCallClosure': mainCallClosure});
 
-    buffer.write(';');
-    buffer.write(jsAst.prettyPrint(invokeMain,
-                 compiler, monitor: compiler.dumpInfoTask));
-    buffer.write(N);
-    addComment('END invoke [main].', buffer);
+    output.add(';');
+    output.addBuffer(jsAst.prettyPrint(invokeMain,
+                     compiler, monitor: compiler.dumpInfoTask));
+    output.add(N);
+    addComment('END invoke [main].', output);
   }
 
-  void emitInitFunction(CodeBuffer buffer) {
+  void emitInitFunction(CodeOutput output) {
     String isolate = namer.currentIsolate;
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression cyclicThrow =
         staticFunctionAccess(backend.getCyclicThrowHelper());
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
     jsAst.FunctionDeclaration decl = js.statement('''
       function init() {
         $isolateProperties = Object.create(null);
         (function(){
          #allClasses = Object.create(null);
          #interceptorsByTag = Object.create(null);
          #leafTags = Object.create(null);
          #finishedClasses = Object.create(null);
         })();
 
         if (#needsLazyInitializer) {
           $lazyInitializerName = function (prototype, staticName, fieldName,
                                            getterName, lazyValue) {
             if (!#lazies) #lazies = Object.create(null);
             #lazies[fieldName] = getterName;
-  
+
             var sentinelUndefined = {};
             var sentinelInProgress = {};
             prototype[fieldName] = sentinelUndefined;
-  
+
             prototype[getterName] = function () {
               var result = $isolate[fieldName];
               try {
                 if (result === sentinelUndefined) {
                   $isolate[fieldName] = sentinelInProgress;
-  
+
                   try {
                     result = $isolate[fieldName] = lazyValue();
                   } finally {
                     // Use try-finally, not try-catch/throw as it destroys the
                     // stack trace.
                     if (result === sentinelUndefined)
                       $isolate[fieldName] = null;
                   }
                 } else {
                   if (result === sentinelInProgress)
                     #cyclicThrow(staticName);
                 }
-  
+
                 return result;
               } finally {
                 $isolate[getterName] = function() { return this[fieldName]; };
               }
             }
           }
         }
 
         // We replace the old Isolate function with a new one that initializes
         // all its fields with the initial (and often final) value of all
@@ skipping 37 matching lines @@
           Isolate.#isolatePropertiesName = isolateProperties;
           if (#outputContainsConstantList) {
             Isolate.#makeConstListProperty = oldIsolate.#makeConstListProperty;
           }
           if (#hasIncrementalSupport) {
             Isolate.#lazyInitializerProperty =
                 oldIsolate.#lazyInitializerProperty;
           }
           return Isolate;
       }
-        
+
       }''', {'allClasses': allClassesAccess,
             'interceptorsByTag': interceptorsByTagAccess,
             'leafTags': leafTagsAccess,
             'finishedClasses': finishedClassesAccess,
             'needsLazyInitializer': needsLazyInitializer,
             'lazies': laziesAccess, 'cyclicThrow': cyclicThrow,
             'isolatePropertiesName': namer.isolatePropertiesName,
             'outputContainsConstantList': task.outputContainsConstantList,
             'makeConstListProperty': makeConstListProperty,
             'hasIncrementalSupport': compiler.hasIncrementalSupport,
             'lazyInitializerProperty': lazyInitializerProperty,});
 
-    buffer.write(jsAst.prettyPrint(decl,
-                 compiler, monitor: compiler.dumpInfoTask).getText());
-    if (compiler.enableMinification) buffer.write('\n');
+    output.addBuffer(
+        jsAst.prettyPrint(decl, compiler, monitor: compiler.dumpInfoTask));
+    if (compiler.enableMinification) {
+      output.add('\n');
+    }
   }
 
-  void emitConvertToFastObjectFunction() {
+  void emitConvertToFastObjectFunction(CodeOutput output) {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
       debugCode.add(js.statement(r'''
         // The following only works on V8 when run with option
         // "--allow-natives-syntax".  We use'new Function' because the
          // miniparser does not understand V8 native syntax.
         if (typeof print === "function") {
           var HasFastProperties =
             new Function("a", "return %HasFastProperties(a)");
           print("Size of global object: "
                    + String(Object.getOwnPropertyNames(properties).length)
                    + ", fast properties " + HasFastProperties(properties));
         }'''));
     }
 
     jsAst.Statement convertToFastObject = js.statement(r'''
       function convertToFastObject(properties) {
         // Create an instance that uses 'properties' as prototype. This should
         // make 'properties' a fast object.
         function MyClass() {};
         MyClass.prototype = properties;
         new MyClass();
         #;
         return properties;
       }''', [debugCode]);
 
-    mainBuffer.write(jsAst.prettyPrint(convertToFastObject, compiler));
-    mainBuffer.write(N);
+    output.addBuffer(jsAst.prettyPrint(convertToFastObject, compiler));
+    output.add(N);
   }
 
-  void writeLibraryDescriptors(CodeBuffer buffer, LibraryElement library) {
+  void writeLibraryDescriptors(CodeOutput output, LibraryElement library) {
     var uri = "";
     if (!compiler.enableMinification || backend.mustPreserveUris) {
       uri = library.canonicalUri;
       if (uri.scheme == 'file' && compiler.outputUri != null) {
         uri = relativize(compiler.outputUri, library.canonicalUri, false);
       }
     }
     ClassBuilder descriptor = elementDescriptors[library];
     if (descriptor == null) {
       // Nothing of the library was emitted.
       // TODO(floitsch): this should not happen. We currently have an example
       // with language/prefix6_negative_test.dart where we have an instance
       // method without its corresponding class.
       return;
     }
 
     String libraryName =
         (!compiler.enableMinification || backend.mustRetainLibraryNames) ?
         library.getLibraryName() :
         "";
 
     jsAst.Fun metadata = metadataEmitter.buildMetadataFunction(library);
 
     jsAst.ObjectInitializer initializers = descriptor.toObjectInitializer();
 
     compiler.dumpInfoTask.registerElementAst(library, metadata);
     compiler.dumpInfoTask.registerElementAst(library, initializers);
-    buffer
-        ..write('["$libraryName",$_')
-        ..write('"${uri}",$_')
-        ..write(metadata == null ? "" : jsAst.prettyPrint(metadata,
-                                              compiler,
-                                              monitor: compiler.dumpInfoTask))
-        ..write(',$_')
-        ..write(namer.globalObjectFor(library))
-        ..write(',$_')
-        ..write(jsAst.prettyPrint(initializers,
-                                  compiler,
-                                  monitor: compiler.dumpInfoTask))
-        ..write(library == compiler.mainApp ? ',${n}1' : "")
-        ..write('],$n');
+    output
+        ..add('["$libraryName",$_')
+        ..add('"${uri}",$_');
+    if (metadata != null) {
+      output.addBuffer(jsAst.prettyPrint(metadata,
+                                         compiler,
+                                         monitor: compiler.dumpInfoTask));
+    }
+    output
+        ..add(',$_')
+        ..add(namer.globalObjectFor(library))
+        ..add(',$_')
+        ..addBuffer(jsAst.prettyPrint(initializers,
+                                      compiler,
+                                      monitor: compiler.dumpInfoTask))
+        ..add(library == compiler.mainApp ? ',${n}1' : "")
+        ..add('],$n');
   }
 
   void emitPrecompiledConstructor(OutputUnit outputUnit,
                                   String constructorName,
                                   jsAst.Expression constructorAst,
                                   List<String> fields) {
     cspPrecompiledFunctionFor(outputUnit).add(
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration(constructorName), constructorAst));
 
     String fieldNamesProperty = FIELD_NAMES_PROPERTY_NAME;
     bool hasIsolateSupport = compiler.hasIsolateSupport;
     jsAst.Node fieldNamesArray =
         hasIsolateSupport ? js.stringArray(fields) : new jsAst.LiteralNull();
 
     cspPrecompiledFunctionFor(outputUnit).add(js.statement(r'''
         {
           #constructorName.builtin$cls = #constructorNameString;
           if (!"name" in #constructorName)
               #constructorName.name = #constructorNameString;
           $desc = $collectedClasses.#constructorName;
           if ($desc instanceof Array) $desc = $desc[1];
           #constructorName.prototype = $desc;
           ''' /* next string is not a raw string */ '''
           if (#hasIsolateSupport) {
             #constructorName.$fieldNamesProperty = #fieldNamesArray;
-          } 
+          }
         }''',
         {"constructorName": constructorName,
          "constructorNameString": js.string(constructorName),
          "hasIsolateSupport": hasIsolateSupport,
          "fieldNamesArray": fieldNamesArray}));
 
     cspPrecompiledConstructorNamesFor(outputUnit).add(js('#', constructorName));
   }
 
   /// Extracts the output name of the compiler's outputUri.
@@ skipping 61 matching lines @@
       String constructorName = mangledName;
       jsAst.Expression constructorAst = js('function() {}');
       List<String> fieldNames = [];
       emitPrecompiledConstructor(mainOutputUnit,
                                  constructorName,
                                  constructorAst,
                                  fieldNames);
     }
   }
 
-  void emitMangledNames() {
+  void emitMangledNames(CodeOutput mainBuffer) {
     if (!mangledFieldNames.isEmpty) {
       var keys = mangledFieldNames.keys.toList();
       keys.sort();
       var properties = [];
       for (String key in keys) {
         var value = js.string('${mangledFieldNames[key]}');
         properties.add(new jsAst.Property(js.string(key), value));
       }
 
       jsAst.Expression mangledNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_NAMES);
       var map = new jsAst.ObjectInitializer(properties);
-      mainBuffer.write(
+      mainBuffer.addBuffer(
           jsAst.prettyPrint(
               js.statement('# = #', [mangledNamesAccess, map]),
               compiler,
               monitor: compiler.dumpInfoTask));
       if (compiler.enableMinification) {
-        mainBuffer.write(';');
+        mainBuffer.add(';');
       }
     }
     if (!mangledGlobalFieldNames.isEmpty) {
       var keys = mangledGlobalFieldNames.keys.toList();
       keys.sort();
       var properties = [];
       for (String key in keys) {
         var value = js.string('${mangledGlobalFieldNames[key]}');
         properties.add(new jsAst.Property(js.string(key), value));
       }
       jsAst.Expression mangledGlobalNamesAccess =
           generateEmbeddedGlobalAccess(embeddedNames.MANGLED_GLOBAL_NAMES);
       var map = new jsAst.ObjectInitializer(properties);
-      mainBuffer.write(
+      mainBuffer.addBuffer(
           jsAst.prettyPrint(
               js.statement('# = #', [mangledGlobalNamesAccess, map]),
               compiler,
               monitor: compiler.dumpInfoTask));
       if (compiler.enableMinification) {
-        mainBuffer.write(';');
+        mainBuffer.add(';');
       }
     }
   }
 
   void checkEverythingEmitted(Iterable<Element> elements) {
     List<Element> pendingStatics;
     if (!compiler.hasIncrementalSupport) {
       pendingStatics =
           Elements.sortedByPosition(elements.where((e) => !e.isLibrary));
 
       pendingStatics.forEach((element) =>
           compiler.reportInfo(
               element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
     }
 
     if (pendingStatics != null && !pendingStatics.isEmpty) {
       compiler.internalError(pendingStatics.first,
           'Pending statics (see above).');
     }
   }
 
   void emitMainOutputUnit(Map<OutputUnit, String> deferredLoadHashes,
                           CodeBuffer nativeBuffer) {
+    LineColumnCollector lineColumnCollector;
+    List<CodeOutputListener> codeOutputListeners;
+    if (generateSourceMap) {
+      lineColumnCollector = new LineColumnCollector();
+      codeOutputListeners = <CodeOutputListener>[lineColumnCollector];
+    }
+
+    OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
+    CodeOutput mainOutput =
+        new StreamCodeOutput(compiler.outputProvider('', 'js'),
+                             codeOutputListeners);
+    outputBuffers[mainOutputUnit] = mainOutput;
+
     bool isProgramSplit = compiler.deferredLoadTask.isProgramSplit;
-    OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
 
-    mainBuffer.write(buildGeneratedBy());
-    addComment(HOOKS_API_USAGE, mainBuffer);
+    mainOutput.add(buildGeneratedBy());
+    addComment(HOOKS_API_USAGE, mainOutput);
 
     if (isProgramSplit) {
       /// For deferred loading we communicate the initializers via this global
       /// variable. The deferred hunks will add their initialization to this.
       /// The semicolon is important in minified mode, without it the
       /// following parenthesis looks like a call to the object literal.
-      mainBuffer..write(
+      mainOutput.add(
           'self.${deferredInitializers} = self.${deferredInitializers} || '
           'Object.create(null);$n');
     }
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
-    mainBuffer.write('(function(${namer.currentIsolate})$_{\n');
+    mainOutput.add('(function(${namer.currentIsolate})$_{\n');
     if (compiler.hasIncrementalSupport) {
-      mainBuffer.write(jsAst.prettyPrint(js.statement(
+      mainOutput.addBuffer(jsAst.prettyPrint(js.statement(
           """
 {
   #helper = #helper || Object.create(null);
   #helper.patch = function(a) { eval(a)};
   #helper.schemaChange = #schemaChange;
   #helper.addMethod = #addMethod;
   #helper.extractStubs = function(array, name, isStatic, originalDescriptor) {
     var descriptor = Object.create(null);
     this.addStubs(descriptor, array, name, isStatic, originalDescriptor, []);
     return descriptor;
   };
 }""",
           { 'helper': js('this.#', [namer.incrementalHelperName]),
             'schemaChange': buildSchemaChangeFunction(),
             'addMethod': buildIncrementalAddMethod() }), compiler));
     }
     if (isProgramSplit) {
       /// We collect all the global state of the, so it can be passed to the
       /// initializer of deferred files.
-      mainBuffer.write('var ${globalsHolder}$_=${_}Object.create(null)$N');
+      mainOutput.add('var ${globalsHolder}$_=${_}Object.create(null)$N');
     }
-    mainBuffer.write('function dart()$_{$n'
+    mainOutput.add('function dart()$_{$n'
         '${_}${_}this.x$_=${_}0$N'
         '${_}${_}delete this.x$N'
         '}$n');
     for (String globalObject in Namer.reservedGlobalObjectNames) {
       // The global objects start as so-called "slow objects". For V8, this
       // means that it won't try to make map transitions as we add properties
       // to these objects. Later on, we attempt to turn these objects into
       // fast objects by calling "convertToFastObject" (see
       // [emitConvertToFastObjectFunction]).
-      mainBuffer.write('var ${globalObject}$_=${_}');
+      mainOutput.add('var ${globalObject}$_=${_}');
       if(isProgramSplit) {
-        mainBuffer.write('${globalsHolder}.$globalObject$_=${_}');
+        mainOutput.add('${globalsHolder}.$globalObject$_=${_}');
       }
-      mainBuffer.write('new dart$N');
+      mainOutput.add('new dart$N');
     }
 
-    mainBuffer.write('function ${namer.isolateName}()$_{}\n');
+    mainOutput.add('function ${namer.isolateName}()$_{}\n');
     if (isProgramSplit) {
-      mainBuffer
-        .write('${globalsHolder}.${namer.isolateName}$_=$_'
-               '${namer.isolateName}$N'
-               '${globalsHolder}.$initName$_=${_}$initName$N');
+      mainOutput
+        .add('${globalsHolder}.${namer.isolateName}$_=$_'
+             '${namer.isolateName}$N'
+             '${globalsHolder}.$initName$_=${_}$initName$N');
     }
-    mainBuffer.write('init()$N$n');
-    mainBuffer.write('$isolateProperties$_=$_$isolatePropertiesName$N');
+    mainOutput.add('init()$N$n');
+    mainOutput.add('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitStaticFunctions(task.outputStaticLists[mainOutputUnit]);
 
     List<ClassElement> classes = task.outputClassLists[mainOutputUnit];
     if (classes != null) {
       for (ClassElement element in classes) {
         generateClass(element, getElementDescriptor(element));
       }
     }
 
     if (compiler.enableMinification) {
-      mainBuffer.write(';');
+      mainOutput.add(';');
     }
 
     if (elementDescriptors.isNotEmpty) {
       Iterable<LibraryElement> libraries =
           task.outputLibraryLists[mainOutputUnit];
       if (libraries == null) libraries = [];
       emitLibraries(libraries);
       emitTypedefs();
-      emitMangledNames();
+      emitMangledNames(mainOutput);
 
       checkEverythingEmitted(elementDescriptors.keys);
 
-      CodeBuffer libraryBuffer = new CodeBuffer();
-      for (LibraryElement library in Elements.sortedByPosition(libraries)) {
-        writeLibraryDescriptors(libraryBuffer, library);
-        elementDescriptors.remove(library);
-      }
-
-      mainBuffer
-          ..write('(')
-          ..write(
+      mainOutput
+          ..add('(')
+          ..addBuffer(
               jsAst.prettyPrint(
                   getReflectionDataParser(this, backend),
                   compiler))
-          ..write(')')
-          ..write('([$n')
-          ..write(libraryBuffer)
-          ..write('])$N');
+          ..add(')')
+          ..add('([$n');
+      for (LibraryElement library in Elements.sortedByPosition(libraries)) {
+        writeLibraryDescriptors(mainOutput, library);
+        elementDescriptors.remove(library);
+      }
+      mainOutput.add('])$N');
     }
 
-    interceptorEmitter.emitGetInterceptorMethods(mainBuffer);
-    interceptorEmitter.emitOneShotInterceptors(mainBuffer);
+    interceptorEmitter.emitGetInterceptorMethods(mainOutput);
+    interceptorEmitter.emitOneShotInterceptors(mainOutput);
 
     if (task.outputContainsConstantList) {
-      emitMakeConstantList(mainBuffer);
+      emitMakeConstantList(mainOutput);
     }
 
     // Constants in checked mode call into RTI code to set type information
     // which may need getInterceptor (and one-shot interceptor) methods, so
     // we have to make sure that [emitGetInterceptorMethods] and
     // [emitOneShotInterceptors] have been called.
-    emitCompileTimeConstants(mainBuffer, mainOutputUnit);
+    emitCompileTimeConstants(mainOutput, mainOutputUnit);
 
-    emitDeferredBoilerPlate(mainBuffer, deferredLoadHashes);
+    emitDeferredBoilerPlate(mainOutput, deferredLoadHashes);
 
     // Static field initializations require the classes and compile-time
     // constants to be set up.
-    emitStaticNonFinalFieldInitializations(mainBuffer, mainOutputUnit);
-    interceptorEmitter.emitInterceptedNames(mainBuffer);
-    interceptorEmitter.emitMapTypeToInterceptor(mainBuffer);
-    emitLazilyInitializedStaticFields(mainBuffer);
+    emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
+    interceptorEmitter.emitInterceptedNames(mainOutput);
+    interceptorEmitter.emitMapTypeToInterceptor(mainOutput);
+    emitLazilyInitializedStaticFields(mainOutput);
 
-    mainBuffer.writeln();
-    mainBuffer.write(nativeBuffer);
+    mainOutput.add('\n');
+    mainOutput.addBuffer(nativeBuffer);
 
-    metadataEmitter.emitMetadata(mainBuffer);
+    metadataEmitter.emitMetadata(mainOutput);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
-    mainBuffer.write('${namer.currentIsolate}$_=${_}null$N');
+    mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
 
-    emitFinishIsolateConstructorInvocation(mainBuffer);
-    mainBuffer.write(
+    emitFinishIsolateConstructorInvocation(mainOutput);
+    mainOutput.add(
         '${namer.currentIsolate}$_=${_}new ${namer.isolateName}()$N');
 
-    emitConvertToFastObjectFunction();
+    emitConvertToFastObjectFunction(mainOutput);
     for (String globalObject in Namer.reservedGlobalObjectNames) {
-      mainBuffer.write('$globalObject = convertToFastObject($globalObject)$N');
+      mainOutput.add('$globalObject = convertToFastObject($globalObject)$N');
     }
     if (DEBUG_FAST_OBJECTS) {
-      mainBuffer.write(r'''
+      mainOutput.add(r'''
           // The following only works on V8 when run with option
           // "--allow-natives-syntax".  We use'new Function' because the
           // miniparser does not understand V8 native syntax.
           if (typeof print === "function") {
             var HasFastProperties =
               new Function("a", "return %HasFastProperties(a)");
             print("Size of global helper object: "
                    + String(Object.getOwnPropertyNames(H).length)
                    + ", fast properties " + HasFastProperties(H));
             print("Size of global platform object: "
                    + String(Object.getOwnPropertyNames(P).length)
                    + ", fast properties " + HasFastProperties(P));
             print("Size of global dart:html object: "
                    + String(Object.getOwnPropertyNames(W).length)
                    + ", fast properties " + HasFastProperties(W));
             print("Size of isolate properties object: "
                    + String(Object.getOwnPropertyNames($).length)
                    + ", fast properties " + HasFastProperties($));
             print("Size of constant object: "
                    + String(Object.getOwnPropertyNames(C).length)
                    + ", fast properties " + HasFastProperties(C));
             var names = Object.getOwnPropertyNames($);
             for (var i = 0; i < names.length; i++) {
               print("$." + names[i]);
             }
           }
 ''');
       for (String object in Namer.userGlobalObjects) {
-      mainBuffer.write('''
+      mainOutput.add('''
         if (typeof print === "function") {
            print("Size of $object: "
                  + String(Object.getOwnPropertyNames($object).length)
                  + ", fast properties " + HasFastProperties($object));
 }
 ''');
       }
     }
 
     jsAst.FunctionDeclaration precompiledFunctionAst =
         buildCspPrecompiledFunctionFor(mainOutputUnit);
-    emitInitFunction(mainBuffer);
-    emitMain(mainBuffer);
-    mainBuffer.write('})()\n');
+    emitInitFunction(mainOutput);
+    emitMain(mainOutput);
+    mainOutput.add('})()\n');
 
     if (compiler.useContentSecurityPolicy) {
-      mainBuffer.write(
+      mainOutput.addBuffer(
           jsAst.prettyPrint(
               precompiledFunctionAst,
               compiler,
               monitor: compiler.dumpInfoTask,
-              allowVariableMinification: false).getText());
+              allowVariableMinification: false));
     }
 
-    String assembledCode = mainBuffer.getText();
     if (generateSourceMap) {
-      outputSourceMap(assembledCode, mainBuffer, '',
-          compiler.sourceMapUri, compiler.outputUri);
-      mainBuffer.write(
+      mainOutput.add(
           generateSourceMapTag(compiler.sourceMapUri, compiler.outputUri));
-      assembledCode = mainBuffer.getText();
     }
 
-    compiler.outputProvider('', 'js')
-        ..add(assembledCode)
-        ..close();
+    mainOutput.close();
+
+    if (generateSourceMap) {
+      outputSourceMap(mainOutput, lineColumnCollector, '',
+          compiler.sourceMapUri, compiler.outputUri);
+    }
   }
 
   /// Used by incremental compilation to patch up the prototype of
   /// [oldConstructor] for use as prototype of [newConstructor].
   jsAst.Fun buildSchemaChangeFunction() {
     return js('''
 function(newConstructor, oldConstructor, superclass) {
   // Invariant: newConstructor.prototype has no interesting properties besides
   // generated accessors. These are copied to oldPrototype which will be
   // updated by other incremental changes.
@@ skipping 128 matching lines @@
           generateClass(element, getElementDescriptor(element));
         }
       }
 
       if (elementDescriptors.isNotEmpty) {
         Iterable<LibraryElement> libraries =
             task.outputLibraryLists[outputUnit];
         if (libraries == null) libraries = [];
         emitLibraries(libraries);
 
+        // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
         CodeBuffer buffer = new CodeBuffer();
         outputBuffers[outputUnit] = buffer;
         for (LibraryElement library in Elements.sortedByPosition(libraries)) {
           writeLibraryDescriptors(buffer, library);
           elementDescriptors.remove(library);
         }
       }
     }
 
     return emitDeferredCode(outputBuffers);
   }
 
   CodeBuffer buildNativesBuffer() {
     // Emit native classes on [nativeBuffer].
+    // TODO(johnniwinther): Avoid creating a [CodeBuffer].
     final CodeBuffer nativeBuffer = new CodeBuffer();
 
     if (nativeClasses.isEmpty) return nativeBuffer;
 
 
     addComment('Native classes', nativeBuffer);
 
-    nativeEmitter.generateNativeClasses(nativeClasses, mainBuffer,
-        additionalProperties);
+    nativeEmitter.generateNativeClasses(nativeClasses, additionalProperties);
 
     nativeEmitter.finishGenerateNativeClasses();
     nativeEmitter.assembleCode(nativeBuffer);
 
     return nativeBuffer;
   }
 
   int emitProgram(Program program) {
     // Shorten the code by using [namer.currentIsolate] as temporary.
     isolateProperties = namer.currentIsolate;
 
     // Emit deferred units first, so we have their hashes.
     // Map from OutputUnit to a hash of its content. The hash uniquely
     // identifies the code of the output-unit. It does not include
     // boilerplate JS code, like the sourcemap directives or the hash
     // itself.
     Map<OutputUnit, String> deferredLoadHashes = emitDeferredOutputUnits();
     CodeBuffer nativeBuffer = buildNativesBuffer();
     emitMainOutputUnit(deferredLoadHashes, nativeBuffer);
 
     if (backend.requiresPreamble &&
         !backend.htmlLibraryIsLoaded) {
       compiler.reportHint(NO_LOCATION_SPANNABLE, MessageKind.PREAMBLE);
     }
-
     // Return the total program size.
     return outputBuffers.values.fold(0, (a, b) => a + b.length);
   }
 
   String generateSourceMapTag(Uri sourceMapUri, Uri fileUri) {
     if (sourceMapUri != null && fileUri != null) {
       String sourceMapFileName = relativize(fileUri, sourceMapUri, false);
       return '''
 
 //# sourceMappingURL=$sourceMapFileName
@@ skipping 18 matching lines @@
       }
     }
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
     return elementDescriptors.putIfAbsent(
         owner,
         () => new ClassBuilder(owner, namer));
   }
 
-  /// Emits support-code for deferred loading into [buffer].
-  void emitDeferredBoilerPlate(CodeBuffer buffer,
+  /// Emits support-code for deferred loading into [output].
+  void emitDeferredBoilerPlate(CodeOutput output,
                                Map<OutputUnit, String> deferredLoadHashes) {
     // Function for checking if a hunk is loaded given its hash.
-    buffer.write(jsAst.prettyPrint(
+    output.addBuffer(jsAst.prettyPrint(
         js('# = function(hunkHash) {'
            '  return !!$deferredInitializers[hunkHash];'
            '}', generateEmbeddedGlobalAccess(embeddedNames.IS_HUNK_LOADED)),
         compiler, monitor: compiler.dumpInfoTask));
-    buffer.write('$N');
+    output.add('$N');
     // Function for initializing a loaded hunk, given its hash.
-    buffer.write(jsAst.prettyPrint(
+    output.addBuffer(jsAst.prettyPrint(
         js('# = function(hunkHash) {'
            '  $deferredInitializers[hunkHash]('
                 '$globalsHolder, ${namer.currentIsolate})'
            '}',
            generateEmbeddedGlobalAccess(
                embeddedNames.INITIALIZE_LOADED_HUNK)),
         compiler, monitor: compiler.dumpInfoTask));
-    buffer.write('$N');
+    output.add('$N');
     // Write a javascript mapping from Deferred import load ids (derrived
     // from the import prefix.) to a list of lists of uris of hunks to load,
     // and a corresponding mapping to a list of hashes used by
     // INITIALIZE_LOADED_HUNK and IS_HUNK_LOADED.
     Map<String, List<String>> deferredLibraryUris =
         new Map<String, List<String>>();
     Map<String, List<String>> deferredLibraryHashes =
         new Map<String, List<String>>();
     compiler.deferredLoadTask.hunksToLoad.forEach(
                   (String loadId, List<OutputUnit>outputUnits) {
@@ skipping 13 matching lines @@
       List<jsAst.Property> properties = new List<jsAst.Property>();
       mapping.forEach((String key, List<String> values) {
         properties.add(new jsAst.Property(js.escapedString(key),
             new jsAst.ArrayInitializer(
                 values.map(js.escapedString).toList())));
       });
       jsAst.Node initializer =
           new jsAst.ObjectInitializer(properties, isOneLiner: true);
 
       jsAst.Node globalName = generateEmbeddedGlobalAccess(name);
-      buffer.write(jsAst.prettyPrint(
+      output.addBuffer(jsAst.prettyPrint(
           js("# = #", [globalName, initializer]),
           compiler, monitor: compiler.dumpInfoTask));
-      buffer.write('$N');
-
+      output.add('$N');
     }
 
     emitMapping(embeddedNames.DEFERRED_LIBRARY_URIS, deferredLibraryUris);
     emitMapping(embeddedNames.DEFERRED_LIBRARY_HASHES,
                 deferredLibraryHashes);
   }
 
   /// Emits code for all output units except the main.
   /// Returns a mapping from outputUnit to a hash of the corresponding hunk that
   /// can be used for calling the initializer.
   Map<OutputUnit, String> emitDeferredCode(
       Map<OutputUnit, CodeBuffer> deferredBuffers) {
 
     Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
 
     for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
       if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) continue;
 
-      CodeBuffer libraryDescriptorBuffer = deferredBuffers[outputUnit];
+      CodeOutput libraryDescriptorBuffer = deferredBuffers[outputUnit];
 
-      CodeBuffer outputBuffer = new CodeBuffer();
+      List<CodeOutputListener> outputListeners = <CodeOutputListener>[];
+      Hasher hasher = new Hasher();
+      outputListeners.add(hasher);
 
-      outputBuffer..write(buildGeneratedBy())
-        ..write('${deferredInitializers}.current$_=$_'
-                'function$_(${globalsHolder}) {$N');
+      LineColumnCollector lineColumnCollector;
+      if (generateSourceMap) {
+        lineColumnCollector = new LineColumnCollector();
+        outputListeners.add(lineColumnCollector);
+      }
+
+      String partPrefix = deferredPartFileName(outputUnit, addExtension: false);
+      CodeOutput output = new StreamCodeOutput(
+          compiler.outputProvider(partPrefix, 'part.js'),
+          outputListeners);
+
+      outputBuffers[outputUnit] = output;
+
+      output
+          ..add(buildGeneratedBy())
+          ..add('${deferredInitializers}.current$_=$_'
+                   'function$_(${globalsHolder}) {$N');
       for (String globalObject in Namer.reservedGlobalObjectNames) {
-        outputBuffer
-            .write('var $globalObject$_=$_'
-                   '${globalsHolder}.$globalObject$N');
+        output
+            .add('var $globalObject$_=$_'
+                     '${globalsHolder}.$globalObject$N');
       }
-      outputBuffer
-          ..write('var init$_=$_${globalsHolder}.init$N')
-          ..write('var ${namer.isolateName}$_=$_'
+      output
+          ..add('var init$_=$_${globalsHolder}.init$N')
+          ..add('var ${namer.isolateName}$_=$_'
                     '${globalsHolder}.${namer.isolateName}$N');
       if (libraryDescriptorBuffer != null) {
       // 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.
-         outputBuffer
-           ..write('var ${namer.currentIsolate}$_=$_$isolatePropertiesName;$n')
-           ..write('(')
-           ..write(
+         output
+           ..add('var ${namer.currentIsolate}$_=$_$isolatePropertiesName;$n')
+           ..add('(')
+           ..addBuffer(
                jsAst.prettyPrint(
                    getReflectionDataParser(this, backend),
                    compiler, monitor: compiler.dumpInfoTask))
-           ..write(')')
-           ..write('([$n')
+           ..add(')')
+           ..add('([$n')
            ..addBuffer(libraryDescriptorBuffer)
-           ..write('])$N');
-
+           ..add('])$N');
       }
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
       // After we have done the setup it must point to the current Isolate.
       // Otherwise all methods/functions accessing isolate variables will
       // access the wrong object.
-      outputBuffer.write("${namer.currentIsolate}$_=${_}arguments[1]$N");
+      output.add("${namer.currentIsolate}$_=${_}arguments[1]$N");
 
-      emitCompileTimeConstants(outputBuffer, outputUnit);
-      emitStaticNonFinalFieldInitializations(outputBuffer, outputUnit);
-      outputBuffer.write('}$N');
+      emitCompileTimeConstants(output, outputUnit);
+      emitStaticNonFinalFieldInitializations(output, outputUnit);
+      output.add('}$N');
 
       if (compiler.useContentSecurityPolicy) {
         jsAst.FunctionDeclaration precompiledFunctionAst =
             buildCspPrecompiledFunctionFor(outputUnit);
 
-        outputBuffer.write(
+        output.addBuffer(
             jsAst.prettyPrint(
                 precompiledFunctionAst, compiler,
                 monitor: compiler.dumpInfoTask,
-                allowVariableMinification: false).getText());
+                allowVariableMinification: false));
       }
 
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
-      String hash = hashOfString(outputBuffer.getText());
+      String hash = hasher.getHash();
 
-      outputBuffer.write('${deferredInitializers}["$hash"]$_=$_'
-                         '${deferredInitializers}.current$N');
+      output.add('${deferredInitializers}["$hash"]$_=$_'
+                       '${deferredInitializers}.current$N');
 
-      String partPrefix = deferredPartFileName(outputUnit, addExtension: false);
       if (generateSourceMap) {
+
         Uri mapUri, partUri;
         Uri sourceMapUri = compiler.sourceMapUri;
         Uri outputUri = compiler.outputUri;
 
         String partName = "$partPrefix.part";
 
         if (sourceMapUri != null) {
           String mapFileName = partName + ".js.map";
           List<String> mapSegments = sourceMapUri.pathSegments.toList();
           mapSegments[mapSegments.length - 1] = mapFileName;
           mapUri = compiler.sourceMapUri.replace(pathSegments: mapSegments);
         }
 
         if (outputUri != null) {
           String partFileName = partName + ".js";
           List<String> partSegments = outputUri.pathSegments.toList();
           partSegments[partSegments.length - 1] = partFileName;
           partUri = compiler.outputUri.replace(pathSegments: partSegments);
         }
 
-        outputSourceMap(outputBuffer.getText(), outputBuffer, partName,
-            mapUri, partUri);
-        outputBuffer.write(generateSourceMapTag(mapUri, partUri));
+        output.add(generateSourceMapTag(mapUri, partUri));
+        output.close();
+        outputSourceMap(output, lineColumnCollector, partName,
+                        mapUri, partUri);
+      } else {
+        output.close();
       }
 
-      outputBuffers[outputUnit] = outputBuffer;
-      compiler.outputProvider(partPrefix, 'part.js')
-        ..add(outputBuffer.getText())
-        ..close();
-
       hunkHashes[outputUnit] = hash;
     }
     return hunkHashes;
   }
 
   String buildGeneratedBy() {
     var suffix = '';
     if (compiler.hasBuildId) suffix = ' version: ${compiler.buildId}';
     return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
   }
 
-  void outputSourceMap(String code, CodeBuffer buffer, String name,
-                       [Uri sourceMapUri, Uri fileUri]) {
+  void outputSourceMap(CodeOutput output,
+                       LineColumnProvider lineColumnProvider,
+                       String name,
+                       [Uri sourceMapUri,
+                        Uri fileUri]) {
     if (!generateSourceMap) return;
     // Create a source file for the compilation output. This allows using
     // [:getLine:] to transform offsets to line numbers in [SourceMapBuilder].
-    SourceFile compiledFile = new StringSourceFile(null, code);
     SourceMapBuilder sourceMapBuilder =
-            new SourceMapBuilder(sourceMapUri, fileUri, compiledFile);
-    buffer.forEachSourceLocation(sourceMapBuilder.addMapping);
+            new SourceMapBuilder(sourceMapUri, fileUri, lineColumnProvider);
+    output.forEachSourceLocation(sourceMapBuilder.addMapping);
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void invalidateCaches() {
     if (!compiler.hasIncrementalSupport) return;
     if (cachedElements.isEmpty) return;
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }