dart2js: Make emitInstanceMember take a Class and not a classElement.

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 78 matching lines @@
       walk(cls.superclass);
       preOrder.add(cls);
     }
     classes.forEach(walk);
 
     // Generate code for each native class into [ClassBuilder]s.
 
     Map<Class, ClassBuilder> builders = new Map<Class, ClassBuilder>();
     for (Class cls in classes) {
       if (cls.isNative) {
-        ClassBuilder builder = generateNativeClass(cls);
+        ClassBuilder builder = createBuilderAndSetIsTrivial(cls);
         builders[cls] = builder;
       }
     }
 
     // Find which classes are needed and which are non-leaf classes.  Any class
     // 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>();
@@ skipping 127 matching lines @@
       }
     }
 
     // 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)) {
         ClassBuilder builder = builders[cls];
-
-        // In CSP mode [emitClassConstructor] and [emitClassGettersSetters] have
-        // a side-effect on "precompiled" functions in [OldEmitter]. For this
-        // reason, it is important that we don't call these methods before we
-        // are certain that a class is needed.
+        assert(builder != null);
 
         emitterTask.oldEmitter.classEmitter.emitConstructorsForCSP(cls);
-
-        // [emitClassGettersSettersForCSP] does not affect whether or not a
-        // class is needed. If getters/setters are emitted, the class has fields
-        // and is therefore non-trivial.
+        emitterTask.oldEmitter.classEmitter.emitFields(
+            cls, builder, classIsNative: true);
+        emitterTask.oldEmitter.classEmitter.emitCheckedClassSetters(
+            cls, builder);
         emitterTask.oldEmitter.classEmitter.emitClassGettersSettersForCSP(
             cls, builder);
+        emitterTask.oldEmitter.classEmitter.emitInstanceMembers(
+            cls, builder);
+        emitterTask.oldEmitter.classEmitter.emitCallStubs(cls, builder);
+        emitterTask.oldEmitter.classEmitter
+            .emitRuntimeTypeInformation(cls, builder);
 
         // Define interceptor class for [classElement].
         emitterTask.oldEmitter.classEmitter.emitClassBuilderWithReflectionData(
             cls,
             builders[cls],
             emitterTask.oldEmitter.getElementDescriptor(classElement));
         emitterTask.oldEmitter.needsClassSupport = true;
       }
     }
   }
@@ skipping 21 matching lines @@
       Class nativeAncestor = nativeAncestorOf(cls);
       if (nativeAncestor != null) {
         map
           .putIfAbsent(nativeAncestor, () => <Class>[])
           .add(cls);
       }
     }
     return map;
   }
 
-  ClassBuilder generateNativeClass(Class cls) {
+  ClassBuilder createBuilderAndSetIsTrivial(Class cls) {
     ClassElement classElement = cls.element;
 
     // TODO(sra): Issue #13731- this is commented out as part of custom element
     // constructor work.
     //assert(!classElement.hasBackendMembers);
     hasNativeClasses = true;
 
     Class superclass = cls.superclass;
     assert(superclass != null);
     assert(superclass.element != compiler.objectClass);
 
     ClassBuilder builder;
     if (compiler.hasIncrementalSupport) {
       builder = cachedBuilders[classElement];
       if (builder != null) return builder;
       builder = new ClassBuilder(classElement, backend.namer);
       cachedBuilders[classElement] = builder;
     } else {
       builder = new ClassBuilder(classElement, backend.namer);
     }
     builder.superName = superclass.name;
 
-    bool hasFields = emitterTask.oldEmitter.classEmitter.emitFields(
-        cls, builder, classIsNative: true);
-    int propertyCount = builder.properties.length;
-    emitterTask.oldEmitter.classEmitter.emitCheckedClassSetters(cls, builder);
-    emitterTask.oldEmitter.classEmitter.emitInstanceMembers(
-        classElement, builder);
-    emitterTask.oldEmitter.classEmitter.emitCallStubs(cls, builder);
-    emitterTask.oldEmitter.classEmitter
-        .emitRuntimeTypeInformation(cls, builder);
+    bool needsAccessor(Field field) {
+      return field.needsGetter ||
+          field.needsUncheckedSetter ||
+          field.needsCheckedSetter;
+    }
 
-    if (!hasFields &&
-        builder.properties.length == propertyCount &&
-        superclass is! MixinApplicationElement) {
-      builder.isTrivial = true;
-    }
+    builder.isTrivial =
+        cls.methods.isEmpty &&
+        cls.isChecks.isEmpty &&
+        cls.callStubs.isEmpty &&
+        superclass is! MixinApplicationElement &&
+        !cls.fields.any(needsAccessor);
 
     return builder;
   }
 
   void finishGenerateNativeClasses() {
     // TODO(sra): Put specialized version of getNativeMethods on
     // `Object.prototype` to avoid checking in `getInterceptor` and
     // specializations.
   }
 
@@ skipping 140 matching lines @@
         targetOutput.add(';');
       }
       targetOutput.addBuffer(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetOutput.add('\n');
     }
 
     targetOutput.add('\n');
   }
 }