dart2js: fully assemble program before emitting it.

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

 // Copyright (c) 2013, 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 ClassEmitter extends CodeEmitterHelper {
 
   ClassStubGenerator get _stubGenerator =>
       new ClassStubGenerator(compiler, namer, backend);
 
   /**
    * Documentation wanted -- johnniwinther
    */
-  void emitClass(Class cls, ClassBuilder enclosingBuilder) {
+  void emitClass(Class cls, ClassBuilder enclosingBuilder, Fragment fragment) {
     ClassElement classElement = cls.element;
 
     assert(invariant(classElement, classElement.isDeclaration));
 
     emitter.needsClassSupport = true;
 
     ClassElement superclass = classElement.superclass;
     String superName = "";
     if (superclass != null) {
       superName = namer.className(superclass);
@@ skipping 19 matching lines @@
     emitNativeInfo(cls, builder);
 
     if (classElement == backend.closureClass) {
       // We add a special getter here to allow for tearing off a closure from
       // itself.
       jsAst.Fun function = js('function() { return this; }');
       String name = namer.getterForMember(Selector.CALL_NAME);
       builder.addProperty(name, function);
     }
 
-    emitClassBuilderWithReflectionData(cls, builder, enclosingBuilder);
+    emitClassBuilderWithReflectionData(cls, builder, enclosingBuilder,
+        fragment);
   }
   /**
   * Emits the precompiled constructor when in CSP mode.
   */
   void emitConstructorsForCSP(Class cls) {
     List<String> fieldNames = <String>[];
 
     if (!compiler.useContentSecurityPolicy) return;
 
     if (!cls.onlyForRti && !cls.isNative) {
       fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
 
     ClassElement classElement = cls.element;
 
     jsAst.Expression constructorAst =
         _stubGenerator.generateClassConstructor(classElement, fieldNames);
 
     String constructorName = namer.className(classElement);
     OutputUnit outputUnit =
         compiler.deferredLoadTask.outputUnitForElement(classElement);
-    emitter.emitPrecompiledConstructor(
+    emitter.assemblePrecompiledConstructor(
         outputUnit, constructorName, constructorAst, fieldNames);
   }
 
   /// Returns `true` if fields added.
   bool emitFields(FieldContainer container,
                   ClassBuilder builder,
                   { bool classIsNative: false,
                     bool emitStatics: false }) {
     Iterable<Field> fields;
     if (container is Class) {
@@ skipping 177 matching lines @@
   }
 
   void emitNativeInfo(Class cls, ClassBuilder builder) {
     if (cls.nativeInfo != null) {
       builder.addProperty(namer.nativeSpecProperty, js.string(cls.nativeInfo));
     }
   }
 
   void emitClassBuilderWithReflectionData(Class cls,
                                           ClassBuilder classBuilder,
-                                          ClassBuilder enclosingBuilder) {
+                                          ClassBuilder enclosingBuilder,
+                                          Fragment fragment) {
     ClassElement classElement = cls.element;
     String className = cls.name;
 
     var metadata = task.metadataCollector.buildMetadataFunction(classElement);
     if (metadata != null) {
       classBuilder.addProperty("@", metadata);
     }
 
     if (backend.isAccessibleByReflection(classElement)) {
       List<DartType> typeVars = classElement.typeVariables;
@@ skipping 14 matching lines @@
     if (emitFields(cls, staticsBuilder, emitStatics: true)) {
       jsAst.ObjectInitializer initializer =
         staticsBuilder.toObjectInitializer();
       compiler.dumpInfoTask.registerElementAst(classElement,
         initializer);
       jsAst.Node property = initializer.properties.single;
       compiler.dumpInfoTask.registerElementAst(classElement, property);
       statics.add(property);
     }
 
+    // TODO(herhut): Do not grab statics out of the properties.
     ClassBuilder classProperties =
-        emitter.elementDescriptors.remove(classElement);
+        emitter.elementDescriptors[fragment].remove(classElement);
     if (classProperties != null) {
       statics.addAll(classProperties.properties);
     }
 
     if (!statics.isEmpty) {
       classBuilder.addProperty('static', new jsAst.ObjectInitializer(statics));
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
     jsAst.ObjectInitializer propertyValue = classBuilder.toObjectInitializer();
     compiler.dumpInfoTask.registerElementAst(classBuilder.element, propertyValue);
     enclosingBuilder.addProperty(className, propertyValue);
 
     String reflectionName = emitter.getReflectionName(classElement, className);
     if (reflectionName != null) {
       if (!backend.isAccessibleByReflection(classElement)) {
         enclosingBuilder.addProperty("+$reflectionName", js.number(0));
       } else {
         List<int> types = <int>[];
         if (classElement.supertype != null) {
           types.add(task.metadataCollector.reifyType(classElement.supertype));
         }
         for (DartType interface in classElement.interfaces) {
           types.add(task.metadataCollector.reifyType(interface));
         }
-        enclosingBuilder.addProperty("+$reflectionName",
-            new jsAst.ArrayInitializer(types.map(js.number).toList()));
+        enclosingBuilder.addProperty("+$reflectionName", js.numArray(types));
       }
     }
   }
 
   /**
    * Invokes [f] for each of the fields of [element].
    *
    * [element] must be a [ClassElement] or a [LibraryElement].
    *
    * If [element] is a [ClassElement], the static fields of the class are
@@ skipping 195 matching lines @@
         ? new Selector.getter(member.name, member.library)
         : new Selector.setter(member.name, member.library);
     String reflectionName = emitter.getReflectionName(selector, name);
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
       builder.addProperty('+$reflectionName', reflectable);
     }
   }
 }