dart2js: store fields in the model and make the emitters use it.

pkg/compiler/lib/src/js_emitter/new_emitter/model_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.
 
 library dart2js.new_js_emitter.model_emitter;
 
 import '../../dart2jslib.dart' show Compiler;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
@@ skipping 267 matching lines @@
 
     js.Expression staticArray =
         new js.ArrayInitializer(staticDescriptors.toList(growable: false));
     js.Expression classArray =
         new js.ArrayInitializer(classDescriptors.toList(growable: false));
 
     return new js.ArrayInitializer([staticArray, classArray]);
   }
 
   js.Expression _generateConstructor(Class cls) {
-    List<String> allFieldNames = <String>[];
+    List<String> fieldNames = <String>[];
 
     // If the class is not directly instantiated we only need it for inheritance
     // or RTI. In either case we don't need its fields.
-    if (cls.isDirectlyInstantiated) {
-      Class currentClass = cls;
-      while (currentClass != null) {
-        // Mixins are not allowed to inject fields.
-        assert(!currentClass.isMixinApplication ||
-               (currentClass as MixinApplication).mixinClass.fields.isEmpty);
-
-        allFieldNames.addAll(
-            currentClass.fields.map((InstanceField field) => field.name));
-        currentClass = currentClass.superclass;
-      }
+    if (cls.isDirectlyInstantiated && !cls.isNative) {
+      fieldNames = cls.fields.map((Field field) => field.name).toList();
     }
     String name = cls.name;
-    String parameters = allFieldNames.join(', ');
-    String assignments = allFieldNames
+    String parameters = fieldNames.join(', ');
+    String assignments = fieldNames
         .map((String field) => "this.$field = $field;\n")
         .join();
     String code = 'function $name($parameters) { $assignments }';
     js.Template template = js.js.uncachedExpressionTemplate(code);
     return template.instantiate(const []);
   }
 
-  Method _generateGetter(InstanceField field) {
+  Method _generateGetter(Field field) {
     String getterTemplateFor(int flags) {
       switch (flags) {
         case 1: return "function() { return this[#]; }";
         case 2: return "function(receiver) { return receiver[#]; }";
         case 3: return "function(receiver) { return this[#]; }";
       }
       return null;
     }
 
     js.Expression fieldName = js.string(field.name);
     js.Expression code = js.js(getterTemplateFor(field.getterFlags), fieldName);
     String getterName = "${namer.getterPrefix}${field.name}";
     return new StubMethod(getterName, code, needsTearOff: false);
   }
 
-  Method _generateSetter(InstanceField field) {
+  Method _generateSetter(Field field) {
     String setterTemplateFor(int flags) {
       switch (flags) {
         case 1: return "function(val) { return this[#] = val; }";
         case 2: return "function(receiver, val) { return receiver[#] = val; }";
         case 3: return "function(receiver, val) { return this[#] = val; }";
       }
       return null;
     }
     js.Expression fieldName = js.string(field.name);
     js.Expression code = js.js(setterTemplateFor(field.setterFlags), fieldName);
     String setterName = "${namer.setterPrefix}${field.name}";
     return new StubMethod(setterName, code, needsTearOff: false);
   }
 
   Iterable<Method> _generateGettersSetters(Class cls) {
     Iterable<Method> getters = cls.fields
-        .where((InstanceField field) => field.needsGetter)
+        .where((Field field) => field.needsGetter)
         .map(_generateGetter);
 
     Iterable<Method> setters = cls.fields
-        .where((InstanceField field) => field.needsSetter)
+        .where((Field field) => field.needsUncheckedSetter)
         .map(_generateSetter);
 
     return [getters, setters].expand((x) => x);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the mixin format.
   static final String mixinFormatDescription =
       "Mixins have no constructor, but a reference to their mixin class.";
 
@@ skipping 212 matching lines @@
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
   #main();  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }