dart2js: move emitClass to emitter.

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 25 matching lines @@
 
   Compiler get compiler => emitterTask.compiler;
   JavaScriptBackend get backend => compiler.backend;
 
   jsAst.Expression get defPropFunction {
     Element element = backend.findHelper('defineProperty');
     return emitterTask.staticFunctionAccess(element);
   }
 
   /**
-   * Writes code to associate dispatch tags with interceptors to [nativeBuffer].
+   * Prepares native classes for emission. Returns the reduced list of classes.
+   *
+   * Removes trivial classes (that can be represented by a super type) and
+   * generates properties that have to be added to classes (native or not).
    *
    * The interceptors are filtered to avoid emitting trivial interceptors.  For
    * example, if the program contains no code that can distinguish between the
    * numerous subclasses of `Element` then we can pretend that `Element` is a
    * 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.  ONLY the native classes are generated here.  [classes]
-   * is sorted in desired output order.
+   * of native classes.  *Only* the native classes are returned. The order of
+   * the returned classes is unchanged. (That is, the returned output might
+   * just have classes removed).
    *
    * [allAdditionalProperties] is used to collect properties that are pushed up
    * from the above optimizations onto a non-native class, e.g, `Interceptor`.
    */
-  void generateNativeClasses(
+  List<Class> prepareNativeClasses(
       List<Class> classes,
       Map<Class, Map<String, jsAst.Expression>> allAdditionalProperties) {
     // 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.
 
-    if (classes.isNotEmpty) {
-      hasNativeClasses = true;
-    }
+    hasNativeClasses = classes.isNotEmpty;
 
     List<Class> preOrder = <Class>[];
     Set<Class> seen = new Set<Class>();
 
     Class objectClass = null;
     Class jsInterceptorClass = null;
     void walk(Class cls) {
       if (cls.element == compiler.objectClass) {
         objectClass = cls;
         return;
@@ skipping 128 matching lines @@
         }
       }
       generateClassInfo(jsInterceptorClass);
       for (Class cls in classes) {
         if (!cls.isNative || neededClasses.contains(cls)) {
           generateClassInfo(cls);
         }
       }
     }
 
-    // Emit the native class interceptors that were actually used.
-    for (Class cls in classes) {
-      assert(!cls.onlyForRti);
-      ClassElement classElement = cls.element;
-      if (!cls.isNative) continue;
-      if (neededClasses.contains(cls)) {
-        // TODO(sra): Issue #13731- this is commented out as part of custom
-        // element constructor work.
-        //assert(!classElement.hasBackendMembers);
+    // TODO(sra): Issue #13731- this is commented out as part of custom
+    // element constructor work.
+    // (floitsch: was run on every native class.)
+    //assert(!classElement.hasBackendMembers);
 
-        ClassBuilder enclosingBuilder =
-            emitterTask.oldEmitter.getElementDescriptor(classElement);
-        emitterTask.oldEmitter.emitClass(cls, enclosingBuilder);
-      }
-    }
+    return classes
+        .where((Class cls) => cls.isNative && neededClasses.contains(cls))
+        .toList();
   }
 
   /**
    * Computes the native classes that are extended (subclassed) by non-native
    * classes and the set non-mative classes that extend them.  (A List is used
    * instead of a Set for out stability).
    */
   Map<Class, List<Class>> computeExtensionPoints(List<Class> classes) {
     Class nativeSuperclassOf(Class cls) {
       if (cls == null) return null;
@@ skipping 183 matching lines @@
         targetOutput.add(';');
       }
       targetOutput.addBuffer(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetOutput.add('\n');
     }
 
     targetOutput.add('\n');
   }
 }