dart2js: Move most of the code_emitter_task code into the program-builder.

pkg/compiler/lib/src/js_emitter/full_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;
 
+  // The following fields will be set to copies of the program-builder's
+  // collector.
+  Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists;
+  Map<OutputUnit, Set<LibraryElement>> outputLibraryLists;
+  List<TypedefElement> typedefsNeededForReflection;
+
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
 
   // TODO(johnniwinther): Wrap these fields in a caching strategy.
   final Set<ConstantValue> cachedEmittedConstants;
   final List<jsAst.Statement> cachedEmittedConstantsAst = <jsAst.Statement>[];
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
@@ skipping 15 matching lines @@
   // The full code that is written to each hunk part-file.
   Map<OutputUnit, CodeOutput> outputBuffers = new Map<OutputUnit, CodeOutput>();
 
   String classesCollector;
   final Map<jsAst.Name, String> mangledFieldNames =
       new HashMap<jsAst.Name, String>();
   final Map<jsAst.Name, String> mangledGlobalFieldNames =
       new HashMap<jsAst.Name, String>();
   final Set<jsAst.Name> recordedMangledNames = new Set<jsAst.Name>();
 
-  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";
 
   /**
    * List of expressions and statements that will be included in the
@@ skipping 466 matching lines @@
                                        jsAst.Expression initialValue) {
       // Note: `namer.currentIsolate` refers to the isolate properties here.
       return js.statement('${namer.currentIsolate}.# = #',
                           [namer.globalPropertyName(element), initialValue]);
     }
 
     bool inMainUnit = (outputUnit == compiler.deferredLoadTask.mainOutputUnit);
     JavaScriptConstantCompiler handler = backend.constants;
     List<jsAst.Statement> parts = <jsAst.Statement>[];
 
-    Iterable<Element> fields = task.outputStaticNonFinalFieldLists[outputUnit];
+    Iterable<Element> fields = outputStaticNonFinalFieldLists[outputUnit];
     // If the outputUnit does not contain any static non-final fields, then
     // [fields] is `null`.
     if (fields != null) {
       for (Element element in fields) {
         compiler.withCurrentElement(element, () {
           ConstantValue constant = handler.getInitialValueFor(element);
           parts.add(buildInitialization(element, constantReference(constant)));
         });
       }
     }
 
-    if (inMainUnit && task.outputStaticNonFinalFieldLists.length > 1) {
+    if (inMainUnit && outputStaticNonFinalFieldLists.length > 1) {
       // In the main output-unit we output a stub initializer for deferred
       // variables, so that `isolateProperties` stays a fast object.
-      task.outputStaticNonFinalFieldLists.forEach(
+      outputStaticNonFinalFieldLists.forEach(
           (OutputUnit fieldsOutputUnit, Iterable<VariableElement> fields) {
         if (fieldsOutputUnit == outputUnit) return;  // Skip the main unit.
         for (Element element in fields) {
           compiler.withCurrentElement(element, () {
             parts.add(buildInitialization(element, jsAst.number(0)));
           });
         }
       });
     }
 
@@ skipping 141 matching lines @@
     return js.statement('#.# = #',
                         [namer.globalObjectForConstant(constant), name,
                          constantInitializerExpression(constant)]);
   }
 
   jsAst.Expression constantListGenerator(jsAst.Expression array) {
     // TODO(floitsch): there is no harm in caching the template.
     return js('${namer.isolateName}.#(#)', [makeConstListProperty, array]);
   }
 
-  jsAst.Statement buildMakeConstantList() {
-    if (task.outputContainsConstantList) {
+  jsAst.Statement buildMakeConstantList(bool outputContainsConstantList) {
+    if (outputContainsConstantList) {
       return js.statement(r'''
           // 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.
           #.# = function (list) {
             list.immutable$list = Array;
             list.fixed$length = Array;
             return list;
           }''',
           [namer.isolateName, makeConstListProperty]);
@@ skipping 26 matching lines @@
               js("convertToFastObject", [])));
     }
 
     parts..add(js.comment('BEGIN invoke [main].'))
          ..add(invokeMain)
          ..add(js.comment('END invoke [main].'));
 
     return new jsAst.Block(parts);
   }
 
-  jsAst.Statement buildInitFunction() {
+  jsAst.Statement buildInitFunction(bool outputContainsConstantList) {
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression getTypeFromNameAccess =
         generateEmbeddedGlobalAccess(embeddedNames.GET_TYPE_FROM_NAME);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
@@ skipping 113 matching lines @@
       }
 
       }''', {'allClasses': allClassesAccess,
             'getTypeFromName': getTypeFromNameAccess,
             'interceptorsByTag': interceptorsByTagAccess,
             'leafTags': leafTagsAccess,
             'finishedClasses': finishedClassesAccess,
             'needsLazyInitializer': needsLazyInitializer,
             'lazies': laziesAccess, 'cyclicThrow': cyclicThrow,
             'isolatePropertiesName': namer.isolatePropertiesName,
-            'outputContainsConstantList': task.outputContainsConstantList,
+            'outputContainsConstantList': outputContainsConstantList,
             'makeConstListProperty': makeConstListProperty,
             'functionThatReturnsNullProperty':
                 backend.rti.getFunctionThatReturnsNullName,
             'hasIncrementalSupport': compiler.hasIncrementalSupport,
             'lazyInitializerProperty': lazyInitializerProperty,});
   }
 
   jsAst.Statement buildConvertToFastObjectFunction() {
     List<jsAst.Statement> debugCode = <jsAst.Statement>[];
     if (DEBUG_FAST_OBJECTS) {
@@ skipping 364 matching lines @@
                        'self.#deferredInitializers || Object.create(null);',
                        {'deferredInitializers': deferredInitializers}));
     }
 
     // Collect the AST for the decriptors
     Map<Element, ClassBuilder> descriptors = elementDescriptors[mainFragment];
     if (descriptors == null) descriptors = const {};
 
     checkEverythingEmitted(descriptors.keys);
 
-    Iterable<LibraryElement> libraries =
-        task.outputLibraryLists[mainOutputUnit];
+    Iterable<LibraryElement> libraries = outputLibraryLists[mainOutputUnit];
     if (libraries == null) libraries = <LibraryElement>[];
 
     List<jsAst.Expression> parts = <jsAst.Expression>[];
     for (LibraryElement library in Elements.sortedByPosition(libraries)) {
       parts.add(generateLibraryDescriptor(library, mainFragment));
       descriptors.remove(library);
     }
 
     if (descriptors.isNotEmpty) {
       List<Element> remainingLibraries = descriptors.keys
@@ skipping 139 matching lines @@
       "isolatePropertiesName": js(isolatePropertiesName),
       "initName": initName,
       "functionThatReturnsNull": buildFunctionThatReturnsNull(),
       "mangledNames": buildMangledNames(),
       "setupProgram": buildSetupProgram(program, compiler, backend, namer, this),
       "setupProgramName": setupProgramName,
       "descriptors": descriptorsAst,
       "cspPrecompiledFunctions": buildCspPrecompiledFunctionFor(mainOutputUnit),
       "getInterceptorMethods": interceptorEmitter.buildGetInterceptorMethods(),
       "oneShotInterceptors": interceptorEmitter.buildOneShotInterceptors(),
-      "makeConstantList": buildMakeConstantList(),
+      "makeConstantList":
+          buildMakeConstantList(program.outputContainsConstantList),
       "compileTimeConstants":  buildCompileTimeConstants(mainFragment.constants,
                                                          isMainFragment: true),
       "deferredBoilerPlate": buildDeferredBoilerPlate(deferredLoadHashes),
       "staticNonFinalInitializers": buildStaticNonFinalFieldInitializations(
           mainOutputUnit),
       "typeToInterceptorMap":
           interceptorEmitter.buildTypeToInterceptorMap(program),
       "lazyStaticFields": buildLazilyInitializedStaticFields(),
       "metadata": buildMetadata(program, mainOutputUnit),
       "convertToFastObject": buildConvertToFastObjectFunction(),
       "convertToSlowObject": buildConvertToSlowObjectFunction(),
       "convertGlobalObjectsToFastObjects":
           buildConvertGlobalObjectToFastObjects(),
       "debugFastObjects": buildDebugFastObjectCode(),
-      "init": buildInitFunction(),
+      "init": buildInitFunction(program.outputContainsConstantList),
       "main": buildMain(mainFragment.invokeMain)
     }));
 
     return new jsAst.Program(statements);
   }
 
   void emitMainOutputUnit(OutputUnit mainOutputUnit, jsAst.Program program) {
     LineColumnCollector lineColumnCollector;
     List<CodeOutputListener> codeOutputListeners;
     if (generateSourceMap) {
@@ skipping 149 matching lines @@
       Program program) {
     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];
+        Iterable<LibraryElement> libraries = outputLibraryLists[outputUnit];
         if (libraries == null) libraries = [];
 
         // TODO(johnniwinther): Avoid creating [CodeBuffer]s.
         List<jsAst.Expression> parts = <jsAst.Expression>[];
         for (LibraryElement library in Elements.sortedByPosition(libraries)) {
           parts.add(generateLibraryDescriptor(library, fragment));
           descriptors.remove(library);
         }
 
         outputs[outputUnit] = new jsAst.ArrayInitializer(parts);
       }
     }
 
     return outputs;
   }
 
   void finalizeTokensInAst(jsAst.Program main,
                            Iterable<jsAst.Program> deferredParts) {
     jsAst.TokenCounter counter = new jsAst.TokenCounter();
     counter.countTokens(main);
     deferredParts.forEach(counter.countTokens);
     task.metadataCollector.finalizeTokens();
     if (backend.namer is jsAst.TokenFinalizer) {
       var finalizer = backend.namer;
       finalizer.finalizeTokens();
     }
   }
 
   int emitProgram(ProgramBuilder programBuilder) {
-    Program program = programBuilder.buildProgram(
-        storeFunctionTypesInMetadata: true);
+    Program program =
+        programBuilder.buildProgram(storeFunctionTypesInMetadata: true);
+
+    outputStaticNonFinalFieldLists =
+        programBuilder.collector.outputStaticNonFinalFieldLists;
+    outputLibraryLists = programBuilder.collector.outputLibraryLists;
+    typedefsNeededForReflection =
+       programBuilder.collector.typedefsNeededForReflection;
 
     assembleProgram(program);
 
     // Construct the ASTs for all deferred output units.
     Map<OutputUnit, jsAst.Program> deferredParts =
         buildOutputAstForDeferredCode(program);
 
     Map<OutputUnit, _DeferredOutputUnitHash> deferredHashTokens =
         new Map<OutputUnit, _DeferredOutputUnitHash>.fromIterables(
           deferredParts.keys,
@@ skipping 34 matching lines @@
       return '''
 
 //# sourceMappingURL=$sourceMapFileName
 ''';
     }
     return '';
   }
 
   ClassBuilder getElementDescriptor(Element element, Fragment fragment) {
     Element owner = element.library;
-    bool isClass = false;
     if (!element.isLibrary && !element.isTopLevel && !element.isNative) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
       ClassElement cls =
           element.enclosingClassOrCompilationUnit.declaration;
       if (compiler.codegenWorld.directlyInstantiatedClasses.contains(cls) &&
           !cls.isNative &&
           compiler.deferredLoadTask.outputUnitForElement(element) ==
               compiler.deferredLoadTask.outputUnitForElement(cls)) {
@@ skipping 279 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }