Add CodeOutput to prepare for emission without in-memory buffers.

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;
@@ skipping 1138 matching lines @@
       if (compiler.hasIncrementalSupport && isMainBuffer) {
         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');
     }
     if (compiler.hasIncrementalSupport && isMainBuffer) {
-      mainBuffer.add(cachedEmittedConstantsBuffer);
+      mainBuffer.write(cachedEmittedConstantsBuffer);
     }
   }
 
   jsAst.Expression buildConstantInitializer(ConstantValue constant) {
     String name = namer.constantName(constant);
     return js('#.# = #',
               [namer.globalObjectForConstant(constant), name,
                constantInitializerExpression(constant)]);
   }
 
@@ skipping 201 matching lines @@
       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.add(jsAst.prettyPrint(convertToFastObject, compiler));
-    mainBuffer.add(N);
+    mainBuffer.write(jsAst.prettyPrint(convertToFastObject, compiler));
+    mainBuffer.write(N);
   }
 
   void writeLibraryDescriptors(CodeBuffer buffer, 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);
       }
     }
@@ skipping 198 matching lines @@
       compiler.internalError(pendingStatics.first,
           'Pending statics (see above).');
     }
   }
 
   void emitMainOutputUnit(Map<OutputUnit, String> deferredLoadHashes,
                           CodeBuffer nativeBuffer) {
     bool isProgramSplit = compiler.deferredLoadTask.isProgramSplit;
     OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
 
-    mainBuffer.add(buildGeneratedBy());
+    mainBuffer.write(buildGeneratedBy());
     addComment(HOOKS_API_USAGE, mainBuffer);
 
     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..add(
+      mainBuffer..write(
           'self.${deferredInitializers} = self.${deferredInitializers} || '
           'Object.create(null);$n');
     }
 
     // Using a named function here produces easier to read stack traces in
     // Chrome/V8.
-    mainBuffer.add('(function(${namer.currentIsolate})$_{\n');
+    mainBuffer.write('(function(${namer.currentIsolate})$_{\n');
     if (compiler.hasIncrementalSupport) {
-      mainBuffer.add(jsAst.prettyPrint(js.statement(
+      mainBuffer.write(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.add('var ${globalsHolder}$_=${_}Object.create(null)$N');
+      mainBuffer.write('var ${globalsHolder}$_=${_}Object.create(null)$N');
     }
-    mainBuffer.add('function dart()$_{$n'
+    mainBuffer.write('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}$_=${_}');
       if(isProgramSplit) {
-        mainBuffer.add('${globalsHolder}.$globalObject$_=${_}');
+        mainBuffer.write('${globalsHolder}.$globalObject$_=${_}');
       }
       mainBuffer.write('new dart$N');
     }
 
-    mainBuffer.add('function ${namer.isolateName}()$_{}\n');
+    mainBuffer.write('function ${namer.isolateName}()$_{}\n');
     if (isProgramSplit) {
       mainBuffer
         .write('${globalsHolder}.${namer.isolateName}$_=$_'
                '${namer.isolateName}$N'
                '${globalsHolder}.$initName$_=${_}$initName$N');
     }
-    mainBuffer.add('init()$N$n');
-    mainBuffer.add('$isolateProperties$_=$_$isolatePropertiesName$N');
+    mainBuffer.write('init()$N$n');
+    mainBuffer.write('$isolateProperties$_=$_$isolatePropertiesName$N');
 
     emitStaticFunctions(task.outputStaticLists[mainOutputUnit]);
 
     // Only output the classesCollector if we actually have any classes.
     if (needsDefineClass ||
         !(nativeClasses.isEmpty &&
           compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty &&
           outputClassLists.values.every((classList) => classList.isEmpty) &&
           typedefsNeededForReflection.isEmpty)) {
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
-      mainBuffer.add('var $classesCollector$_=${_}Object.create(null)$N$n');
+      mainBuffer.write('var $classesCollector$_=${_}Object.create(null)$N$n');
     }
 
     List<ClassElement> classes = task.outputClassLists[mainOutputUnit];
     if (classes != null) {
       for (ClassElement element in classes) {
         generateClass(element, getElementDescriptor(element));
       }
     }
 
     if (compiler.enableMinification) {
@@ skipping 17 matching lines @@
       }
 
       mainBuffer
           ..write('(')
           ..write(
               jsAst.prettyPrint(
                   getReflectionDataParser(classesCollector, backend),
                   compiler))
           ..write(')')
           ..write('([$n')
-          ..add(libraryBuffer)
+          ..write(libraryBuffer)
           ..write('])$N');
 
       emitFinishClassesInvocationIfNecessary(mainBuffer);
     }
 
     interceptorEmitter.emitGetInterceptorMethods(mainBuffer);
     interceptorEmitter.emitOneShotInterceptors(mainBuffer);
 
     if (task.outputContainsConstantList) {
       emitMakeConstantList(mainBuffer);
     }
 
     // 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);
 
     emitDeferredBoilerPlate(mainBuffer, 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);
 
     mainBuffer.writeln();
-    mainBuffer.add(nativeBuffer);
+    mainBuffer.write(nativeBuffer);
 
     metadataEmitter.emitMetadata(mainBuffer);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
-    mainBuffer.add('${namer.currentIsolate}$_=${_}null$N');
+    mainBuffer.write('${namer.currentIsolate}$_=${_}null$N');
 
     emitFinishIsolateConstructorInvocation(mainBuffer);
-    mainBuffer.add(
+    mainBuffer.write(
         '${namer.currentIsolate}$_=${_}new ${namer.isolateName}()$N');
 
     emitConvertToFastObjectFunction();
     for (String globalObject in Namer.reservedGlobalObjectNames) {
-      mainBuffer.add('$globalObject = convertToFastObject($globalObject)$N');
+      mainBuffer.write('$globalObject = convertToFastObject($globalObject)$N');
     }
     if (DEBUG_FAST_OBJECTS) {
-      mainBuffer.add(r'''
+      mainBuffer.write(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: "
+            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]);
-           }
-         }
+            var names = Object.getOwnPropertyNames($);
+            for (var i = 0; i < names.length; i++) {
+              print("$." + names[i]);
+            }
+          }
 ''');
       for (String object in Namer.userGlobalObjects) {
-      mainBuffer.add('''
+      mainBuffer.write('''
         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.add('})()\n');
+    mainBuffer.write('})()\n');
 
     if (compiler.useContentSecurityPolicy) {
       mainBuffer.write(
           jsAst.prettyPrint(
               precompiledFunctionAst,
               compiler,
               monitor: compiler.dumpInfoTask,
               allowVariableMinification: false).getText());
     }
 
     String assembledCode = mainBuffer.getText();
     if (generateSourceMap) {
       outputSourceMap(assembledCode, mainBuffer, '',
           compiler.sourceMapUri, compiler.outputUri);
-      mainBuffer.add(
+      mainBuffer.write(
           generateSourceMapTag(compiler.sourceMapUri, compiler.outputUri));
       assembledCode = mainBuffer.getText();
     }
 
     compiler.outputProvider('', 'js')
         ..add(assembledCode)
         ..close();
     compiler.assembledCode = assembledCode;
   }
 
@@ skipping 371 matching lines @@
                 precompiledFunctionAst, compiler,
                 monitor: compiler.dumpInfoTask,
                 allowVariableMinification: false).getText());
       }
 
       // 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());
 
-      outputBuffer.add('${deferredInitializers}["$hash"]$_=$_'
-                       '${deferredInitializers}.current$N');
+      outputBuffer.write('${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.add(generateSourceMapTag(mapUri, partUri));
+        outputBuffer.write(generateSourceMapTag(mapUri, partUri));
       }
 
       outputBuffers[outputUnit] = outputBuffer;
       compiler.outputProvider(partPrefix, 'part.js')
         ..add(outputBuffer.getText())
         ..close();
 
       hunkHashes[outputUnit] = hash;
     }
     return hunkHashes;
@@ skipping 26 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }