dart2js: start using the model in the old emitter.

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 736 matching lines @@
         invariant(classElement, builder.functionType == null);
         invariant(classElement, builder.fieldMetadata == null);
         properties.properties.addAll(builder.properties);
       } else {
         classEmitter.generateClass(
             classElement, properties, additionalProperties[classElement]);
       }
     });
   }
 
-  void emitStaticFunctions(List<Element> staticFunctions) {
-    for (Element element in staticFunctions) {
+  void emitStaticFunctions(Iterable<Method> staticFunctions) {
+    // We need to filter out null-elements for the interceptors.
+    Iterable<Element> elements = staticFunctions
+        .where((Method method) => method.element != null)
+        .map((Method method) => method.element);
+
+    for (Element element in elements) {
       ClassBuilder builder = new ClassBuilder(element, namer);
       containerBuilder.addMember(element, builder);
       getElementDescriptor(element).properties.addAll(builder.properties);
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeOutput output,
                                               OutputUnit outputUnit) {
     void emitInitialization(Element element, jsAst.Expression initialValue) {
       jsAst.Expression init =
@@ skipping 100 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(CodeOutput output, OutputUnit outputUnit) {
-    List<ConstantValue> constants = outputConstantLists[outputUnit];
-    if (constants == null) return;
+  void emitCompileTimeConstants(CodeOutput output,
+                                List<Constant> constants,
+                                {bool isMainFragment}) {
+    assert(isMainFragment != null);
+
+    if (constants.isEmpty) return;
     CodeOutput constantOutput = output;
-    if (compiler.hasIncrementalSupport && outputUnit.isMainOutput) {
+    if (compiler.hasIncrementalSupport && isMainFragment) {
       constantOutput = cachedEmittedConstantsBuffer;
     }
-    for (ConstantValue constant in constants) {
-      if (compiler.hasIncrementalSupport && outputUnit.isMainOutput) {
-        if (cachedEmittedConstants.contains(constant)) continue;
-        cachedEmittedConstants.add(constant);
+    for (Constant constant in constants) {
+      ConstantValue constantValue = constant.value;
+      if (compiler.hasIncrementalSupport && isMainFragment) {
+        if (cachedEmittedConstants.contains(constantValue)) continue;
+        cachedEmittedConstants.add(constantValue);
       }
-      jsAst.Expression init = buildConstantInitializer(constant);
+      jsAst.Expression init = buildConstantInitializer(constantValue);
       constantOutput.addBuffer(jsAst.prettyPrint(init, compiler,
                                          monitor: compiler.dumpInfoTask));
       constantOutput.add('$N');
     }
-    if (compiler.hasIncrementalSupport && outputUnit.isMainOutput) {
+    if (compiler.hasIncrementalSupport && isMainFragment) {
       output.addBuffer(constantOutput);
     }
   }
 
   jsAst.Expression buildConstantInitializer(ConstantValue constant) {
     String name = namer.constantName(constant);
     return js('#.# = #',
               [namer.globalObjectForConstant(constant), name,
                constantInitializerExpression(constant)]);
   }
@@ skipping 361 matching lines @@
     }
   }
 
   void emitTypedefs() {
     OutputUnit mainOutputUnit = compiler.deferredLoadTask.mainOutputUnit;
 
     // Emit all required typedef declarations into the main output unit.
     // TODO(karlklose): unify required classes and typedefs to declarations
     // and have builders for each kind.
     for (TypedefElement typedef in typedefsNeededForReflection) {
-      OutputUnit mainUnit = compiler.deferredLoadTask.mainOutputUnit;
       LibraryElement library = typedef.library;
       // TODO(karlklose): add a TypedefBuilder and move this code there.
       DartType type = typedef.alias;
       int typeIndex = metadataEmitter.reifyType(type);
       ClassBuilder builder = new ClassBuilder(typedef, namer);
       builder.addProperty(embeddedNames.TYPEDEF_TYPE_PROPERTY_NAME,
                           js.number(typeIndex));
       builder.addProperty(embeddedNames.TYPEDEF_PREDICATE_PROPERTY_NAME,
                           js.boolean(true));
 
@@ skipping 73 matching lines @@
           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,
+  void emitLibrary(Library library) {
+    emitStaticFunctions(library.statics);
+
+    Iterable<ClassElement> classes =
+        library.classes.map((Class cls) => cls.element);
+    for (ClassElement element in classes) {
+      generateClass(element, getElementDescriptor(element));
+    }
+
+    LibraryElement libraryElement = library.element;
+    ClassBuilder builder = getElementDescriptor(libraryElement);
+    classEmitter.emitFields(library.element, builder, emitStatics: true);
+  }
+
+  void emitMainOutputUnit(Program program,
+                          Map<OutputUnit, String> deferredLoadHashes,
                           CodeBuffer nativeBuffer) {
+    Fragment mainFragment = program.fragments.first;
+    OutputUnit mainOutputUnit = mainFragment.outputUnit;
+
     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;
+    bool isProgramSplit = program.isSplit;
 
     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.
       mainOutput.add(
@@ skipping 59 matching lines @@
     if (isProgramSplit) {
       mainOutput.add(
           '${globalsHolder}.${namer.isolateName}$_=$_${namer.isolateName}$N'
           '${globalsHolder}.$initName$_=${_}$initName$N'
           '${globalsHolder}.$parseReflectionDataName$_=$_'
             '$parseReflectionDataName$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));
-      }
-    }
+    mainFragment.libraries.forEach(emitLibrary);
 
     Iterable<LibraryElement> libraries =
         task.outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = [];
-    emitLibraries(libraries);
     emitTypedefs();
     emitMangledNames(mainOutput);
 
     checkEverythingEmitted(elementDescriptors.keys);
 
     CodeBuffer libraryBuffer = new CodeBuffer();
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
       writeLibraryDescriptors(libraryBuffer, library);
       elementDescriptors.remove(library);
     }
@@ skipping 17 matching lines @@
     interceptorEmitter.emitOneShotInterceptors(mainOutput);
 
     if (task.outputContainsConstantList) {
       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(mainOutput, mainOutputUnit);
+    emitCompileTimeConstants(
+        mainOutput, mainFragment.constants, isMainFragment: true);
 
     emitDeferredBoilerPlate(mainOutput, deferredLoadHashes);
 
     if (compiler.deferredMapUri != null) {
       outputDeferredMap();
     }
 
     // Static field initializations require the classes and compile-time
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
@@ skipping 198 matching lines @@
     holder[name] = method;
   }
   if (isStatic) globalFunctionsAccess[name] = method;
 }""");
   }
 
   /// 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() {
-    if (!compiler.deferredLoadTask.isProgramSplit) return const {};
+  Map<OutputUnit, String> emitDeferredOutputUnits(Program program) {
+    if (!program.isSplit) return const {};
 
     Map<OutputUnit, CodeBuffer> outputBuffers =
         new Map<OutputUnit, CodeBuffer>();
 
-    for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
-      if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) continue;
+    for (Fragment fragment in program.deferredFragments) {
+      OutputUnit outputUnit = fragment.outputUnit;
 
-      List<Element> functions = task.outputStaticLists[outputUnit];
-      if (functions != null) {
-        emitStaticFunctions(functions);
-      }
 
-      List<ClassElement> classes = task.outputClassLists[outputUnit];
-      if (classes != null) {
-        for (ClassElement element in classes) {
-          generateClass(element, getElementDescriptor(element));
-        }
-      }
+      fragment.libraries.forEach(emitLibrary);
 
       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);
+    return emitDeferredCode(program, 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, 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();
+    Map<OutputUnit, String> deferredLoadHashes =
+        emitDeferredOutputUnits(program);
     CodeBuffer nativeBuffer = buildNativesBuffer();
-    emitMainOutputUnit(deferredLoadHashes, nativeBuffer);
+    emitMainOutputUnit(program, 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) {
@@ skipping 102 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, String> hunkHashes = new Map<OutputUnit, String>();
 
-    for (OutputUnit outputUnit in compiler.deferredLoadTask.allOutputUnits) {
-      if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) continue;
+    for (Fragment fragment in program.deferredFragments) {
+      OutputUnit outputUnit = fragment.outputUnit;
 
       CodeOutput libraryDescriptorBuffer = deferredBuffers[outputUnit];
 
       List<CodeOutputListener> outputListeners = <CodeOutputListener>[];
       Hasher hasher = new Hasher();
       outputListeners.add(hasher);
 
       LineColumnCollector lineColumnCollector;
       if (generateSourceMap) {
         lineColumnCollector = new LineColumnCollector();
@@ skipping 43 matching lines @@
       // 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.
       output.add("${namer.currentIsolate}$_=${_}arguments[1]$N");
 
-      emitCompileTimeConstants(output, outputUnit);
+      emitCompileTimeConstants(
+          output, fragment.constants, isMainFragment: false);
       emitStaticNonFinalFieldInitializations(output, outputUnit);
       output.add('}$N');
 
       if (compiler.useContentSecurityPolicy) {
         jsAst.FunctionDeclaration precompiledFunctionAst =
             buildCspPrecompiledFunctionFor(outputUnit);
 
         output.addBuffer(
             jsAst.prettyPrint(
                 precompiledFunctionAst, compiler,
@@ skipping 85 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }