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

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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.
 
 library dart2js.js_emitter.program_builder;
 
-import '../js_emitter.dart' show computeMixinClass;
+import '../js_emitter.dart' show computeMixinClass, Emitter;
 import '../model.dart';
 
 import '../../common.dart';
 import '../../js/js.dart' as js;
 
 import '../../js_backend/js_backend.dart' show
     Namer,
     JavaScriptBackend,
     JavaScriptConstantCompiler;
 
 import '../js_emitter.dart' show
     ClassStubGenerator,
     CodeEmitterTask,
     InterceptorStubGenerator,
     MainCallStubGenerator,
     ParameterStubGenerator,
     RuntimeTypeGenerator,
     TypeTestProperties;
 
 import '../../elements/elements.dart' show ParameterElement, MethodElement;
 
 import '../../universe/universe.dart' show Universe, TypeMaskSet;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 
+part 'collector.dart';
 part 'registry.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final Compiler _compiler;
   final Namer namer;
   final CodeEmitterTask _task;
 
+  /// Contains the collected information the program builder used to build
+  /// the model.
+  // The collector will be filled on the first call to `buildProgram`.
+  // It is stored and publicly exposed for backwards compatibility.
+  final Collector collector;
+
   final Registry _registry;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
   ProgramBuilder(Compiler compiler,
-                 this.namer,
-                 this._task)
+                 Namer namer,
+                 this._task,
+                 Emitter emitter,
+                 Emitter oldEmitter,
+                 Set<ClassElement> rtiNeededClasses)
       : this._compiler = compiler,
+        this.namer = namer,
+        this.collector = new Collector(
+            compiler, namer, rtiNeededClasses, emitter, oldEmitter),
         this._registry = new Registry(compiler);
 
   JavaScriptBackend get backend => _compiler.backend;
   Universe get universe => _compiler.codegenWorld;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
   Set<Class> _unneededNativeClasses;
 
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
+    collector.collect();
+
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _compiler.deferredLoadTask.allOutputUnits.forEach(
         _registry.registerOutputUnit);
-    _task.outputClassLists.forEach(_registry.registerElements);
-    _task.outputStaticLists.forEach(_registry.registerElements);
-    _task.outputConstantLists.forEach(_registerConstants);
-    _task.outputStaticNonFinalFieldLists.forEach(_registry.registerElements);
+    collector.outputClassLists.forEach(_registry.registerElements);
+    collector.outputStaticLists.forEach(_registry.registerElements);
+    collector.outputConstantLists.forEach(_registerConstants);
+    collector.outputStaticNonFinalFieldLists.forEach(
+        _registry.registerElements);
 
     // TODO(kasperl): There's code that implicitly needs access to the special
     // $ holder so we have to register that. Can we track if we have to?
     _registry.registerHolder(r'$');
 
     // We need to run the native-preparation before we build the output. The
     // preparation code, in turn needs the classes to be set up.
     // We thus build the classes before building their containers.
-    _task.outputClassLists.forEach((OutputUnit _, List<ClassElement> classes) {
+    collector.outputClassLists.forEach((OutputUnit _, List<ClassElement> classes) {
       classes.forEach(_buildClass);
     });
 
     // Resolve the superclass references after we've processed all the classes.
     _classes.forEach((ClassElement element, Class c) {
       if (element.superclass != null) {
         c.setSuperclass(_classes[element.superclass]);
         assert(c.superclass != null);
       }
       if (c is MixinApplication) {
         c.setMixinClass(_classes[computeMixinClass(element)]);
         assert(c.mixinClass != null);
       }
     });
 
-    List<Class> nativeClasses = _task.nativeClassesAndSubclasses
+    List<Class> nativeClasses = collector.nativeClassesAndSubclasses
         .map((ClassElement classElement) => _classes[classElement])
         .toList();
 
-    _unneededNativeClasses =
-        _task.nativeEmitter.prepareNativeClasses(nativeClasses);
+    Set<ClassElement> interceptorClassesNeededByConstants =
+        collector.computeInterceptorsReferencedFromConstants();
+    Set<ClassElement> classesModifiedByEmitRTISupport =
+        _task.typeTestRegistry.computeClassesModifiedByEmitRuntimeTypeSupport();
+
+
+    _unneededNativeClasses = _task.nativeEmitter.prepareNativeClasses(
+        nativeClasses, interceptorClassesNeededByConstants,
+        classesModifiedByEmitRTISupport);
 
     MainFragment mainFragment = _buildMainFragment(_registry.mainLibrariesMap);
     Iterable<Fragment> deferredFragments =
         _registry.deferredLibrariesMap.map(_buildDeferredFragment);
 
     List<Fragment> fragments = new List<Fragment>(_registry.librariesMapCount);
     fragments[0] = mainFragment;
     fragments.setAll(1, deferredFragments);
 
     _markEagerClasses();
@@ skipping 12 matching lines @@
     }
 
     return new Program(
         fragments,
         holders,
         _buildLoadMap(),
         _buildTypeToInterceptorMap(),
         _task.metadataCollector,
         finalizers,
         needsNativeSupport: needsNativeSupport,
-        outputContainsConstantList: _task.outputContainsConstantList,
+        outputContainsConstantList: collector.outputContainsConstantList,
         hasIsolateSupport: _compiler.hasIsolateSupport);
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
   }
 
   /// Builds a map from loadId to outputs-to-load.
   Map<String, List<Fragment>> _buildLoadMap() {
     Map<String, List<Fragment>> loadMap = <String, List<Fragment>>{};
@@ skipping 40 matching lines @@
         _buildLibraries(librariesMap),
         _buildStaticNonFinalFields(librariesMap),
         _buildStaticLazilyInitializedFields(librariesMap),
         _buildConstants(librariesMap));
     _outputs[librariesMap.outputUnit] = result;
     return result;
   }
 
   List<Constant> _buildConstants(LibrariesMap librariesMap) {
     List<ConstantValue> constantValues =
-        _task.outputConstantLists[librariesMap.outputUnit];
+        collector.outputConstantLists[librariesMap.outputUnit];
     if (constantValues == null) return const <Constant>[];
     return constantValues.map((ConstantValue value) => _constants[value])
         .toList(growable: false);
   }
 
   List<StaticField> _buildStaticNonFinalFields(LibrariesMap librariesMap) {
     List<VariableElement> staticNonFinalFields =
-         _task.outputStaticNonFinalFieldLists[librariesMap.outputUnit];
+         collector.outputStaticNonFinalFieldLists[librariesMap.outputUnit];
     if (staticNonFinalFields == null) return const <StaticField>[];
 
     return staticNonFinalFields
         .map(_buildStaticField)
         .toList(growable: false);
   }
 
   StaticField _buildStaticField(Element element) {
     JavaScriptConstantCompiler handler = backend.constants;
     ConstantValue initialValue = handler.getInitialValueFor(element);
@@ skipping 96 matching lines @@
     js.Name name = namer.className(element);
 
     return new Class(
         element, name, null, [], instanceFields, [], [], [], [], [], null,
         isDirectlyInstantiated: true,
         onlyForRti: false,
         isNative: element.isNative);
   }
 
   Class _buildClass(ClassElement element) {
-    bool onlyForRti = _task.classesOnlyNeededForRti.contains(element);
+    bool onlyForRti = collector.classesOnlyNeededForRti.contains(element);
 
     List<Method> methods = [];
     List<StubMethod> callStubs = <StubMethod>[];
 
     ClassStubGenerator classStubGenerator =
         new ClassStubGenerator(_compiler, namer, backend);
     RuntimeTypeGenerator runtimeTypeGenerator =
         new RuntimeTypeGenerator(_compiler, _task, namer);
 
     void visitMember(ClassElement enclosing, Element member) {
@@ skipping 423 matching lines @@
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       js.Name name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }