dart2js: native classes go through the normal code path.

pkg/compiler/lib/src/js_emitter/program_builder.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.
 
 library dart2js.js_emitter.program_builder;
 
 import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
 
 import '../common.dart';
@@ skipping 40 matching lines @@
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
+  Set<Class> _unneededNativeClasses;
+
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _compiler.deferredLoadTask.allOutputUnits.forEach(
         _registry.registerOutputUnit);
     _task.outputClassLists.forEach(_registry.registerElements);
     _task.outputStaticLists.forEach(_registry.registerElements);
     _task.outputConstantLists.forEach(_registerConstants);
     _task.outputStaticNonFinalFieldLists.forEach(_registry.registerElements);
 
     // TODO(kasperl): There's code that implicitly needs access to the special
     // $ holder so we have to register that. Can we track if we have to?
     _registry.registerHolder(r'$');
 
-    MainFragment mainOutput = _buildMainOutput(_registry.mainLibrariesMap);
-    Iterable<Fragment> deferredOutputs = _registry.deferredLibrariesMap
-        .map((librariesMap) => _buildDeferredOutput(mainOutput, librariesMap));
-
-    List<Fragment> outputs = new List<Fragment>(_registry.librariesMapCount);
-    outputs[0] = mainOutput;
-    outputs.setAll(1, deferredOutputs);
-
-    List<Class> nativeClasses = _task.nativeClasses
-        .map((ClassElement classElement) {
-          Class result = _classes[classElement];
-          return (result == null) ? _buildClass(classElement) : result;
-        })
-        .toList();
+    // We need to run the native-preparation before we build the output. The
+    // preparation code, in turn needs the classes to be set up.
+    // We thus build the classes before building their containers.
+    _task.outputClassLists.forEach((OutputUnit _, List<ClassElement> classes) {
+      classes.forEach(_buildClass);
+    });
 
     // Resolve the superclass references after we've processed all the classes.
     _classes.forEach((ClassElement element, Class c) {
       if (element.superclass != null) {
         c.setSuperclass(_classes[element.superclass]);
         assert(c.superclass != null);
       }
       if (c is MixinApplication) {
         c.setMixinClass(_classes[computeMixinClass(element)]);
         assert(c.mixinClass != null);
       }
     });
 
+    List<Class> nativeClasses = _task.nativeClassesAndSubclasses
+        .map((ClassElement classElement) => _classes[classElement])
+        .toList();
+
     Map<Class, Map<String, js.Expression>> additionalProperties =
         new Map<Class, Map<String, js.Expression>>();
 
-    List<Class> neededNativeClasses =
+    _unneededNativeClasses =
         _task.nativeEmitter.prepareNativeClasses(
             nativeClasses,
             additionalProperties);
 
+    MainFragment mainOutput = _buildMainOutput(_registry.mainLibrariesMap);
+    Iterable<Fragment> deferredOutputs = _registry.deferredLibrariesMap
+        .map((librariesMap) => _buildDeferredOutput(mainOutput, librariesMap));
+
+    List<Fragment> outputs = new List<Fragment>(_registry.librariesMapCount);
+    outputs[0] = mainOutput;
+    outputs.setAll(1, deferredOutputs);
+
     _markEagerClasses();
 
+    bool containsNativeClasses =
+        nativeClasses.length != _unneededNativeClasses.length;
+
     return new Program(
         outputs,
-        neededNativeClasses,
         additionalProperties,
         _buildLoadMap(),
-        outputContainsNativeClasses: neededNativeClasses.isNotEmpty,
+        outputContainsNativeClasses: containsNativeClasses,
         outputContainsConstantList: _task.outputContainsConstantList);
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
   }
 
   /// Builds a map from loadId to outputs-to-load.
   Map<String, List<Fragment>> _buildLoadMap() {
-    List<OutputUnit> convertHunks(List<OutputUnit> hunks) {
-      return hunks.map((OutputUnit unit) => _outputs[unit])
-          .toList(growable: false);
-    }
-
     Map<String, List<Fragment>> loadMap = <String, List<Fragment>>{};
     _compiler.deferredLoadTask.hunksToLoad
         .forEach((String loadId, List<OutputUnit> outputUnits) {
       loadMap[loadId] = outputUnits
           .map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     });
     return loadMap;
   }
 
@@ skipping 71 matching lines @@
     JavaScriptConstantCompiler handler = backend.constants;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     return Elements.sortedByPosition(lazyFields)
         .map(_buildLazyField)
         .where((field) => field != null)  // Happens when the field was unused.
         .toList(growable: false);
   }
 
   StaticField _buildLazyField(Element element) {
-    JavaScriptConstantCompiler handler = backend.constants;
     js.Expression code = backend.generatedCode[element];
     // The code is null if we ended up not needing the lazily
     // initialized field after all because of constant folding
     // before code generation.
     if (code == null) return null;
 
     String name = namer.getNameOfGlobalField(element);
     bool isFinal = element.isFinal;
     bool isLazy = true;
     return new StaticField(element,
@@ skipping 20 matching lines @@
         .map(_buildStaticMethod)
         .toList();
 
     if (library == backend.interceptorsLibrary) {
       statics.addAll(_generateGetInterceptorMethods());
       statics.addAll(_generateOneShotInterceptors());
     }
 
     List<Class> classes = elements
         .where((e) => e is ClassElement)
-        .map(_buildClass)
+        .map((ClassElement classElement) => _classes[classElement])
+        .where((Class cls) =>
+            !cls.isNative || !_unneededNativeClasses.contains(cls))
         .toList(growable: false);
 
     bool visitStatics = true;
     List<Field> staticFieldsForReflection = _buildFields(library, visitStatics);
 
     return new Library(library, uri, statics, classes,
                        staticFieldsForReflection);
   }
 
   /// HACK for Try.
@@ skipping 236 matching lines @@
       _registry.registerConstant(outputUnit, constantValue);
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 }