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

pkg/compiler/lib/src/js_emitter/native_emitter.dart

 // Copyright (c) 2012, 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 NativeEmitter {
 
   final Map<Element, ClassBuilder> cachedBuilders;
 
@@ skipping 43 matching lines @@
    * leaf class, and all instances of subclasses of `Element` are instances of
    * `Element`.
    *
    * There is also a performance benefit (in addition to the obvious code size
    * benefit), due to how [getNativeInterceptor] works.  Finding the interceptor
    * of a leaf class in the hierarchy is more efficient that a non-leaf, so it
    * improves performance when more classes can be treated as leaves.
    *
    * [classes] contains native classes, mixin applications, and user subclasses
    * of native classes.
+   *
+   * [interceptorClassesNeededByConstants] contains the interceptors that are
+   * referenced by constants.
+   *
+   * [classesModifiedByEmitRTISupport] contains the list of classes that must
+   * exist, because runtime-type support adds information to the class.
    */
-  Set<Class> prepareNativeClasses(List<Class> classes) {
+  Set<Class> prepareNativeClasses(List<Class> classes,
+      Set<ClassElement> interceptorClassesNeededByConstants,
+      Set<ClassElement> classesModifiedByEmitRTISupport) {
     assert(classes.every((Class cls) => cls != null));
 
     hasNativeClasses = classes.isNotEmpty;
 
     // Compute a pre-order traversal of the subclass forest.  We actually want a
     // post-order traversal but it is easier to compute the pre-order and use it
     // in reverse.
     List<Class> preOrder = <Class>[];
     Set<Class> seen = new Set<Class>();
 
@@ skipping 20 matching lines @@
     // that is not needed can be treated as a leaf class equivalent to some
     // needed class.
 
     Set<Class> neededClasses = new Set<Class>();
     Set<Class> nonLeafClasses = new Set<Class>();
 
     Map<Class, List<Class>> extensionPoints = computeExtensionPoints(preOrder);
 
     neededClasses.add(objectClass);
 
-    Set<ClassElement> neededByConstant = emitterTask
-        .computeInterceptorsReferencedFromConstants();
-    Set<ClassElement> modifiedClasses = emitterTask.typeTestRegistry
-        .computeClassesModifiedByEmitRuntimeTypeSupport();
-
     for (Class cls in preOrder.reversed) {
       ClassElement classElement = cls.element;
       // Post-order traversal ensures we visit the subclasses before their
       // superclass.  This makes it easy to tell if a class is needed because a
       // subclass is needed.
       bool needed = false;
       if (!cls.isNative) {
         // Mixin applications (native+mixin) are non-native, so [classElement]
         // has already been emitted as a regular class.  Mark [classElement] as
         // 'needed' to ensure the native superclass is needed.
         needed = true;
       } else if (!isTrivialClass(cls)) {
         needed = true;
-      } else if (neededByConstant.contains(classElement)) {
+      } else if (interceptorClassesNeededByConstants.contains(classElement)) {
         needed = true;
-      } else if (modifiedClasses.contains(classElement)) {
+      } else if (classesModifiedByEmitRTISupport.contains(classElement)) {
         // TODO(9556): Remove this test when [emitRuntimeTypeSupport] no longer
         // adds information to a class prototype or constructor.
         needed = true;
       } else if (extensionPoints.containsKey(cls)) {
         needed = true;
       }
       if (cls.isNative &&
           native.nativeTagsForcedNonLeaf(classElement)) {
         needed = true;
         nonLeafClasses.add(cls);
@@ skipping 202 matching lines @@
     // used.  We should also use an interceptor if the check can't be satisfied
     // by a native class in case we get a native instance that tries to spoof
     // the type info.  i.e the criteria for whether or not to use an interceptor
     // is whether the receiver can be native, not the type of the test.
     if (element == null || !element.isClass) return false;
     ClassElement cls = element;
     if (Elements.isNativeOrExtendsNative(cls)) return true;
     return isSupertypeOfNativeClass(element);
   }
 }