dart2js: don't emit unneeded native info.

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 150 matching lines @@
         }
         if (sufficingInterceptor == objectClass) {
           sufficingInterceptor = jsInterceptorClass;
         }
         leafTags
             .putIfAbsent(sufficingInterceptor, () => new Set<String>())
             .addAll(nativeTags);
       }
     }
 
-    // Add properties containing the information needed to construct maps used
-    // by getNativeInterceptor and custom elements.
-    if (compiler.enqueuer.codegen.nativeEnqueuer
-        .hasInstantiatedNativeClasses()) {
+    Set<Class> unneededClasses = classes
+        .where((Class cls) => cls.isNative && !neededClasses.contains(cls))
+        .toSet();
+
+    // If native classes are emitted, add properties containing the information
+    // needed to construct maps used by getNativeInterceptor and custom
+    // elements.
+    if (classes.length != unneededClasses.length) {

[floitsch, 2015/02/26 18:12:12]

Explain when/why this can happen.

From what I understand this happens when we only execute methods like 'toString'
or 'hashCode' on the native class (basically the ones provided by 'Object').
(We might invoke others, but they don't count if they are inlined).

Is that correct?

[zarah, 2015/02/27 09:03:48]

It happens in the case you mention, I am not completely sure whether or not it
can happen in other cases as well. 

The point is, however, that in the program builder, this is the condition we use
to set the "outputContainsNativeClasses" field on the model which is used to
decide whether or not to emit the code that handles the native info. Here we
used the method hasInstatiatedNativeClasses() to decide whether we add native
info at all which is inconsistent. So I think the two conditions should be the
same since it does not make sense to emit native info if we are not going to use
it.

       void generateClassInfo(Class cls) {
         // Property has the form:
         //
         //    "%": "leafTag1|leafTag2|...;nonleafTag1|...;Class1|Class2|...",
         //
         // If there is no data following a semicolon, the semicolon can be
         // omitted.
 
         String formatTags(Iterable<String> tags) {
           if (tags == null) return '';
@@ skipping 26 matching lines @@
           generateClassInfo(cls);
         }
       }
     }
 
     // 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))
-        .toSet();
+    return unneededClasses;
   }
 
   /**
    * 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 232 matching lines @@
           }
     ''', {'info': infoAccess,
           'constructor': constructorAccess,
           'subclassRead': subclassRead,
           'interceptorsByTagAccess': interceptorsByTagAccess,
           'leafTagsAccess': leafTagsAccess,
           'nativeSuperclassTagName': embeddedNames.NATIVE_SUPERCLASS_TAG_NAME,
           'allowNativesSubclassing': true});
   }
 }