dart2js: native classes go through the normal code path.

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);
   }
 
   /**
-   * Prepares native classes for emission. Returns the reduced list of classes.
+   * Prepares native classes for emission. Returns the unneeded classes.

[herhut, 2015/01/26 14:58:08]

Why is this better? Do you expect that this set is smaller?

[floitsch, 2015/01/26 17:57:50]

I think it's smaller, but more importantly it's a clear set.
If I return the "needed" classes, it would be a needed *subset* of all needed
classes. Basically I would need to do something like `if (!cls.isNative ||
needed.contains(cls))`. And even then it would not be clear that I caught all
classes: does it include mixins?...

    *
    * 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 returned. The order of
-   * the returned classes is unchanged. (That is, the returned output might
-   * just have classes removed).
+   * of native classes.
    *
    * [allAdditionalProperties] is used to collect properties that are pushed up
    * from the above optimizations onto a non-native class, e.g, `Interceptor`.
    */
-  List<Class> prepareNativeClasses(
+  Set<Class> prepareNativeClasses(
       List<Class> classes,
       Map<Class, Map<String, jsAst.Expression>> allAdditionalProperties) {
+    assert(classes.every((Class cls) => cls != null));

[herhut, 2015/01/26 14:58:08]

Why is this needed?

[floitsch, 2015/01/26 17:57:50]

If the mapping from classElement to Class fails in the program builder it could
fail here.
I can remove it, but I don't think it's expensive.

[herhut, 2015/01/27 09:50:29]

I was just curious how this could happen.

+
+    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.
-
-    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 133 matching lines @@
         }
       }
     }
 
     // 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);
 
     return classes
-        .where((Class cls) => cls.isNative && neededClasses.contains(cls))
-        .toList();
+        .where((Class cls) => cls.isNative && !neededClasses.contains(cls))
+        .toSet();
   }
 
   /**
    * 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 27 matching lines @@
     }
 
     return
         cls.methods.isEmpty &&
         cls.isChecks.isEmpty &&
         cls.callStubs.isEmpty &&
         !cls.superclass.isMixinApplication &&
         !cls.fields.any(needsAccessor);
   }
 
-  void finishGenerateNativeClasses() {
-    // TODO(sra): Put specialized version of getNativeMethods on
-    // `Object.prototype` to avoid checking in `getInterceptor` and
-    // specializations.
-  }
-
   void potentiallyConvertDartClosuresToJs(
       List<jsAst.Statement> statements,
       FunctionElement member,
       List<jsAst.Parameter> stubParameters) {
     FunctionSignature parameters = member.functionSignature;
     Element converter = backend.findHelper('convertDartClosureToJS');
     jsAst.Expression closureConverter =
         emitterTask.staticFunctionAccess(converter);
     parameters.forEachParameter((ParameterElement parameter) {
       String name = parameter.name;
@@ skipping 130 matching lines @@
         targetOutput.add(';');
       }
       targetOutput.addBuffer(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetOutput.add('\n');
     }
 
     targetOutput.add('\n');
   }
 }