Don't create builders to determine if a native class is trivial or not.

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 42 matching lines @@
    *
    * 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.
    *
-   * [additionalProperties] is used to collect properties that are pushed up
+   * [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> classes,
-      Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties) {
+      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;
+    }
+
     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;
       }
       if (cls.element == backend.jsInterceptorClass) {
         jsInterceptorClass = cls;
         return;
       }
       if (seen.contains(cls)) return;
       seen.add(cls);
       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 = 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>();
 
     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.
-      ClassBuilder builder = builders[cls];
       bool needed = false;
-      if (builder == null) {
-        assert(!cls.isNative);
+      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 (!builder.isTrivial) {
+      } else if (!isTrivialClass(cls)) {
         needed = true;
       } else if (neededByConstant.contains(classElement)) {
         needed = true;
       } else if (modifiedClasses.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;
       }
@@ skipping 63 matching lines @@
         StringBuffer sb = new StringBuffer(leafStr);
         if (nonleafStr != '') {
           sb..write(';')..write(nonleafStr);
         }
         if (extensions != null) {
           sb..write(';')
             ..writeAll(extensions.map((Class cls) => cls.name), '|');
         }
         String encoding = sb.toString();
 
-        ClassBuilder builder = builders[cls];
-        if (builder == null) {
-          // No builder because this is an intermediate mixin application or
-          // Interceptor - these are not direct native classes.
-          if (encoding != '') {
-            Map<String, jsAst.Expression> properties =
-                additionalProperties.putIfAbsent(cls.element,
-                    () => new Map<String, jsAst.Expression>());
-            properties[backend.namer.nativeSpecProperty] = js.string(encoding);
-          }
-        } else {
-          builder.addProperty(
-              backend.namer.nativeSpecProperty, js.string(encoding));
+        if (cls.isNative || encoding != '') {
+          Map<String, jsAst.Expression> properties =
+              allAdditionalProperties.putIfAbsent(cls,
+                  () => new Map<String, jsAst.Expression>());
+          properties[backend.namer.nativeSpecProperty] = js.string(encoding);
         }
       }
       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)) {
-        ClassBuilder builder = builders[cls];
-        assert(builder != null);
+        // TODO(sra): Issue #13731- this is commented out as part of custom
+        // element constructor work.
+        //assert(!classElement.hasBackendMembers);
 
-        emitterTask.oldEmitter.classEmitter.emitConstructorsForCSP(cls);
-        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;
+        ClassBuilder enclosingBuilder =
+            emitterTask.oldEmitter.getElementDescriptor(classElement);
+        emitterTask.oldEmitter.emitClass(cls, enclosingBuilder);
       }
     }
   }
 
   /**
    * 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) {
@@ skipping 14 matching lines @@
       Class nativeAncestor = nativeAncestorOf(cls);
       if (nativeAncestor != null) {
         map
           .putIfAbsent(nativeAncestor, () => <Class>[])
           .add(cls);
       }
     }
     return map;
   }
 
-  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 isTrivialClass(Class cls) {
     bool needsAccessor(Field field) {
       return field.needsGetter ||
           field.needsUncheckedSetter ||
           field.needsCheckedSetter;
     }
 
-    builder.isTrivial =
+    return
         cls.methods.isEmpty &&
         cls.isChecks.isEmpty &&
         cls.callStubs.isEmpty &&
-        !superclass.isMixinApplication &&
+        !cls.superclass.isMixinApplication &&
         !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.
   }
 
   void potentiallyConvertDartClosuresToJs(
       List<jsAst.Statement> statements,
@@ skipping 138 matching lines @@
         targetOutput.add(';');
       }
       targetOutput.addBuffer(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetOutput.add('\n');
     }
 
     targetOutput.add('\n');
   }
 }