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

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, 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 OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 34 matching lines @@
   Set<ClassElement> get neededClasses => task.neededClasses;
   Map<OutputUnit, List<ClassElement>> get outputClassLists
       => task.outputClassLists;
   Map<OutputUnit, List<ConstantValue>> get outputConstantLists
       => task.outputConstantLists;
   List<ClassElement> get nativeClasses => task.nativeClasses;
   final Map<String, String> mangledFieldNames = <String, String>{};
   final Map<String, String> mangledGlobalFieldNames = <String, String>{};
   final Set<String> recordedMangledNames = new Set<String>();
 
-  final Map<ClassElement, Map<String, jsAst.Expression>> additionalProperties =
-      new Map<ClassElement, Map<String, jsAst.Expression>>();
+  final Map<Class, Map<String, jsAst.Expression>> additionalProperties =
+      new Map<Class, Map<String, jsAst.Expression>>();
 
   List<TypedefElement> get typedefsNeededForReflection =>
       task.typedefsNeededForReflection;
 
   JavaScriptBackend get backend => compiler.backend;
   TypeVariableHandler get typeVariableHandler => backend.typeVariableHandler;
 
   String get _ => space;
   String get space => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
@@ skipping 642 matching lines @@
         var \$desc;
         #;
         return #;
       }''',
         [cspPrecompiledFunctionFor(outputUnit),
          new jsAst.ArrayInitializer(
              cspPrecompiledConstructorNamesFor(outputUnit))]);
   }
 
   void emitClass(Class cls, ClassBuilder enclosingBuilder) {
-    // Native classes are handled by the native emitter.
-    assert(!cls.isNative || cls.onlyForRti);
-
     ClassElement classElement = cls.element;
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder cachedBuilder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder = new ClassBuilder(classElement, namer);
               classEmitter.emitClass(
-                  cls, builder, additionalProperties[classElement]);
+                  cls, builder, additionalProperties[cls]);
               return builder;
             });
         invariant(classElement, cachedBuilder.fields.isEmpty);
         invariant(classElement, cachedBuilder.superName == null);
         invariant(classElement, cachedBuilder.functionType == null);
         invariant(classElement, cachedBuilder.fieldMetadata == null);
         enclosingBuilder.properties.addAll(cachedBuilder.properties);
       } else {
         classEmitter.emitClass(
-            cls, enclosingBuilder, additionalProperties[classElement]);
+            cls, enclosingBuilder, additionalProperties[cls]);
       }
     });
   }
 
   void emitStaticFunctions(Iterable<Method> staticFunctions) {
     if (staticFunctions == null) return;
     // We need to filter out null-elements for the interceptors.
     Iterable<Element> elements = staticFunctions
         .where((Method method) => method.element != null)
         .map((Method method) => method.element);
@@ skipping 1345 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }