dart2js: Use JavaScript asts instead of CodeBuffers when assembling output units.

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 992 matching lines @@
           return object.__proto__ &&
                  object.__proto__.p === cls.prototype.p;
          })();
       ''');
     }
 
     output.addBuffer(jsAst.prettyPrint(supportsDirectProtoAccess, compiler));
     output.add(N);
   }
 
-  void writeLibraryDescriptor(CodeOutput output, LibraryElement library,
-                              Fragment fragment) {
+  jsAst.Expression generateLibraryDescriptor(LibraryElement library,
+                                             Fragment fragment) {
     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[fragment][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 = task.metadataCollector.buildMetadataFunction(library);
 
-    jsAst.ObjectInitializer initializers = descriptor.toObjectInitializer();
+    ClassBuilder descriptor = elementDescriptors[fragment][library];
+
+    jsAst.ObjectInitializer initializer;
+    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.
+      initializer = new jsAst.ObjectInitializer([]);
+    } else {
+      initializer = descriptor.toObjectInitializer();
+    }
 
     compiler.dumpInfoTask.registerElementAst(library, metadata);
-    compiler.dumpInfoTask.registerElementAst(library, initializers);
-    output
-        ..add('["$libraryName",$_')
-        ..add('"${uri}",$_');
-    if (metadata != null) {
-      output.addBuffer(jsAst.prettyPrint(metadata,
-                                         compiler,
-                                         monitor: compiler.dumpInfoTask));
+    compiler.dumpInfoTask.registerElementAst(library, initializer);
+
+    List<jsAst.Expression> parts = <jsAst.Expression>[];
+    parts..add(js.string(libraryName))
+         ..add(js.string(uri.toString()))
+         ..add(metadata == null ? new jsAst.ArrayHole() : metadata)
+         ..add(js.name(namer.globalObjectFor(library)))
+         ..add(initializer);
+    if (library == compiler.mainApp) {
+      parts.add(js.number(1));
     }
-    output
-        ..add(',$_')
-        ..add(namer.globalObjectFor(library))
-        ..add(',$_')
-        ..addBuffer(jsAst.prettyPrint(initializers,
-                                      compiler,
-                                      monitor: compiler.dumpInfoTask))
-        ..add(library == compiler.mainApp ? ',${n}1' : "")
-        ..add('],$n');
+
+    return new jsAst.ArrayInitializer(parts);
   }
 
   void assemblePrecompiledConstructor(OutputUnit outputUnit,
                                       String constructorName,
                                       jsAst.Expression constructorAst,
                                       List<String> fields) {
     cspPrecompiledFunctionFor(outputUnit).add(
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration(constructorName), constructorAst));
 
@@ skipping 253 matching lines @@
     Iterable<LibraryElement> libraries =
         task.outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = [];
     emitMangledNames(mainOutput);
 
     Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
     if (descriptors == null) descriptors = const {};
 
     checkEverythingEmitted(descriptors.keys);
 
-    CodeBuffer libraryBuffer = new CodeBuffer();
+    List<jsAst.Expression> parts = <jsAst.Expression>[];
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
-      writeLibraryDescriptor(libraryBuffer, library, mainFragment);
+      parts.add(generateLibraryDescriptor(library, mainFragment));
       descriptors.remove(library);
     }
 
     if (descriptors.isNotEmpty) {
       List<Element> remainingLibraries = descriptors.keys
           .where((Element e) => e is LibraryElement)
           .toList();
 
       // The remaining descriptors are only accessible through reflection.
       // The program builder does not collect libraries that only
       // contain typedefs that are used for reflection.
       for (LibraryElement element in remainingLibraries) {
         assert(element is LibraryElement || compiler.hasIncrementalSupport);
         if (element is LibraryElement) {
-          writeLibraryDescriptor(libraryBuffer, element, mainFragment);
+          parts.add(generateLibraryDescriptor(element, mainFragment));
           descriptors.remove(element);
         }
       }
     }
+    jsAst.ArrayInitializer descriptorsAst = new jsAst.ArrayInitializer(parts);
 
     bool needsNativeSupport = program.needsNativeSupport;
     mainOutput.addBuffer(
         jsAst.prettyPrint(
             buildSetupProgram(program, compiler, backend, namer, this),
             compiler));
 
     // The argument to reflectionDataParser is assigned to a temporary 'dart'
     // so that 'dart.' will appear as the prefix to dart methods in stack
     // traces and profile entries.
-    mainOutput..add('var dart = [$n')
-              ..addBuffer(libraryBuffer)
-              ..add(']$N');
+    mainOutput..add('var dart =')
+              ..addBuffer(jsAst.prettyPrint(descriptorsAst, compiler))
+              ..add('$N');
     if (compiler.useContentSecurityPolicy) {
       jsAst.Statement precompiledFunctionAst =
           buildCspPrecompiledFunctionFor(mainOutputUnit);
       mainOutput.addBuffer(
           jsAst.prettyPrint(
               precompiledFunctionAst,
               compiler,
               monitor: compiler.dumpInfoTask,
               allowVariableMinification: false));
       mainOutput.add(N);
@@ skipping 223 matching lines @@
 }""");
   }
 
   /// Returns a 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> emitDeferredOutputUnits(Program program) {
     if (!program.isSplit) return const {};
 
-    Map<OutputUnit, CodeBuffer> outputBuffers =
-        new Map<OutputUnit, CodeBuffer>();
+    Map<OutputUnit, jsAst.Expression> outputs =
+        new Map<OutputUnit, jsAst.Expression>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
       Map<Element, ClassBuilder> descriptors = elementDescriptors[fragment];
 
       if (descriptors != null && descriptors.isNotEmpty) {
         Iterable<LibraryElement> libraries =
             task.outputLibraryLists[outputUnit];
         if (libraries == null) libraries = [];
 
         // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
-        CodeBuffer buffer = new CodeBuffer();
-        outputBuffers[outputUnit] = buffer;
+        List<jsAst.Expression> parts = <jsAst.Expression>[];
         for (LibraryElement library in Elements.sortedByPosition(libraries)) {
-          writeLibraryDescriptor(buffer, library, fragment);
+          parts.add(generateLibraryDescriptor(library, fragment));
           descriptors.remove(library);
         }
+
+        outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
     }
 
-    return emitDeferredCode(program, outputBuffers);
+    return emitDeferredCode(program, outputs);
   }
 
   int emitProgram(ProgramBuilder programBuilder) {
     Program program = programBuilder.buildProgram(
         storeFunctionTypesInMetadata: true);
 
     assembleProgram(program);
 
     // Shorten the code by using [namer.currentIsolate] as temporary.
     isolateProperties = namer.currentIsolate;
@@ skipping 122 matching lines @@
     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(
       Program program,
-      Map<OutputUnit, CodeBuffer> deferredBuffers) {
+      Map<OutputUnit, jsAst.Expression> deferredAsts) {
 
     Map<OutputUnit, String> hunkHashes = new Map<OutputUnit, String>();
 
     for (Fragment fragment in program.deferredFragments) {
       OutputUnit outputUnit = fragment.outputUnit;
 
-      CodeOutput libraryDescriptorBuffer = deferredBuffers[outputUnit];
+      jsAst.Expression libraryDescriptor = deferredAsts[outputUnit];
 
       List<CodeOutputListener> outputListeners = <CodeOutputListener>[];
       Hasher hasher = new Hasher();
       outputListeners.add(hasher);
 
       LineColumnCollector lineColumnCollector;
       if (generateSourceMap) {
         lineColumnCollector = new LineColumnCollector();
         outputListeners.add(lineColumnCollector);
       }
@@ skipping 16 matching lines @@
                      '${globalsHolder}.$globalObject$N');
       }
       output
           ..add('var init$_=$_${globalsHolder}.init$N')
           ..add('var $setupProgramName$_=$_'
                     '$globalsHolder.$setupProgramName$N')
           ..add('var ${namer.isolateName}$_=$_'
                     '${globalsHolder}.${namer.isolateName}$N');
       String typesAccess =
           generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
-      if (libraryDescriptorBuffer != null) {
+      if (libraryDescriptor != 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.
         output
             ..add('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
             // The argument to reflectionDataParser is assigned to a temporary
             // 'dart' so that 'dart.' will appear as the prefix to dart methods
             // in stack traces and profile entries.
-            ..add('var dart = [$n ')
-            ..addBuffer(libraryDescriptorBuffer)
-            ..add(']$N');
+            ..add('var dart = $n ')
+            ..addBuffer(jsAst.prettyPrint(libraryDescriptor, compiler))
+            ..add('$N');
 
         if (compiler.useContentSecurityPolicy) {
           jsAst.Statement precompiledFunctionAst =
               buildCspPrecompiledFunctionFor(outputUnit);
 
           output.addBuffer(
               jsAst.prettyPrint(
                   precompiledFunctionAst, compiler,
                   monitor: compiler.dumpInfoTask,
                   allowVariableMinification: false));
@@ skipping 108 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }