dart2js: Support mixins in the new emitter.

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 238 matching lines @@
         [ js.string(e.name), js.number(e.holder.index), emitClass(e) ]);
 
     js.Expression staticArray = new js.ArrayInitializer.from(staticDescriptors);
     js.Expression classArray = new js.ArrayInitializer.from(classDescriptors);
 
     return new js.ArrayInitializer.from([staticArray, classArray]);
   }
 
   js.Expression _generateConstructor(Class cls) {
     List<String> allFieldNames = <String>[];
-    Class currentClass = cls;
-    while (currentClass != null) {
-      allFieldNames.addAll(
-          currentClass.fields.map((InstanceField field) => field.name));
-      currentClass = currentClass.superclass;
+
+    // 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;
+      }
     }
     String name = cls.name;
     String parameters = allFieldNames.join(', ');
     String assignments = allFieldNames
         .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 []);
   }
@@ skipping 35 matching lines @@
         .map(_generateGetter);
 
     Iterable<Method> setters = cls.fields
         .where((InstanceField field) => field.needsSetter)
         .map(_generateSetter);
 
     return [getters, setters].expand((x) => x);
   }
 
   js.Expression emitClass(Class cls) {
-    List elements = [ js.string(cls.superclassName),
-                      js.number(cls.superclassHolderIndex),
-                      _generateConstructor(cls) ];
+    if (cls.isMixinApplication) return emitMixinApplication(cls);
+
+    List elements = [js.string(cls.superclassName),
+                     js.number(cls.superclassHolderIndex),
+                     _generateConstructor(cls)];
     Iterable<Method> methods = cls.methods;
     Iterable<Method> gettersSetters = _generateGettersSetters(cls);
     Iterable<Method> allMethods = [methods, gettersSetters].expand((x) => x);
-    elements.addAll(allMethods.expand((e) => [ js.string(e.name), e.code ]));
+    elements.addAll(allMethods.expand((e) => [js.string(e.name), e.code]));
     return unparse(compiler, new js.ArrayInitializer.from(elements));
   }
 
+  // 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.";
+
+  js.Expression emitMixinApplication(MixinApplication cls) {
+    List elements = [js.string(cls.superclassName),
+                     js.number(cls.superclassHolderIndex),
+                     js.string(cls.mixinClass.name),
+                     js.number(cls.mixinClass.holder.index)];
+    return unparse(compiler, new js.ArrayInitializer.from(elements));
+  }
+
   js.Expression emitLazyInitializer(StaticField field) {
     assert(field.isLazy);
     return unparse(compiler, field.code);
   }
 
   js.Expression emitStaticMethod(StaticMethod method) {
     return unparse(compiler, method.code);
   }
-}
 
-final String boilerplate = r"""
+  static final String boilerplate = """
 {
 // Declare deferred-initializer global.
 #;
 
 !function(start, program) {
 
   // Initialize holder objects.
   #;
 
   function setupProgram() {
@@ skipping 77 matching lines @@
     // to resolve superclass references without constructing instances. The
     // resolve property also serves as a marker that indicates whether or not
     // a class has been resolved yet.
     patch.resolve = resolve;
     holder[name] = patch;
   }
 
   function compileConstructor(name, descriptor) {
     descriptor = compile(name, descriptor);
     var prototype = determinePrototype(descriptor);
+    // $mixinFormatDescription.
+    if (typeof descriptor[2] !== 'function') {
+      return compileMixinConstructor(name, prototype, descriptor);
+    }
     var constructor = descriptor[2];
     for (var i = 3; i < descriptor.length; i += 2) {
       prototype[descriptor[i]] = descriptor[i + 1];
     }
     constructor.prototype = prototype;
     return constructor;
   }
 
+  function compileMixinConstructor(name, prototype, descriptor) {
+    // $mixinFormatDescription.
+    var mixinName = descriptor[2];
+    var mixinHolderIndex = descriptor[3];
+    var mixin = holders[mixinHolderIndex][mixinName];
+    if (mixin.resolve) mixin = mixin.resolve();
+    var mixinPrototype = mixin.prototype;
+
+    // Fill the prototype with the mixin's properties.
+    var mixinProperties = Object.keys(mixinPrototype);
+    for (var i = 0; i < mixinProperties.length; i++) {
+      var p = mixinProperties[i];
+      prototype[p] = mixinPrototype[p];
+    }
+    // Since this is a mixin application the constructor will actually never
+    // be invoked. We only use its prototype for the application's subclasses. 
+    var constructor = function() {};
+    constructor.prototype = prototype;
+    return constructor;
+  }
+
   function determinePrototype(descriptor) {
     var superclassName = descriptor[0];
     if (!superclassName) return { };
 
     // Look up the superclass constructor function in the right holder.
     var holderIndex = descriptor[1];
     var superclass = holders[holderIndex][superclassName];
     if (superclass.resolve) superclass = superclass.resolve();
 
     // Create a new prototype object chained to the superclass prototype.
     var intermediate = function() { };
     intermediate.prototype = superclass.prototype;
     return new intermediate();
   }
 
   function compile(__name__, __s__) {
     'use strict';
     // TODO(floitsch): evaluate the performance impact of the string
     // concatenations.
-    return eval(__s__ + "\n//# sourceURL=" + __name__ + ".js");
+    return eval(__s__ + "\\n//# sourceURL=" + __name__ + ".js");
   }
 
   if (#) { // outputContainsConstantList
     function makeConstList(list) {
       // By assigning a function to the properties they become part of the
       // hidden class. The actual values of the fields don't matter, since we
       // only check if they exist.
-      list.immutable$list = Array;
-      list.fixed$length = Array;
+      list.immutable\$list = Array;
+      list.fixed\$length = Array;
       return list;
     }
   }
 
   setupProgram();
 
   // Initialize globals.
   #;
 
   // Initialize constants.
   #;
 
   // Initialize static non-final fields.
   #;
 
   // Initialize eager classes.
   #;
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
   if (true) #();  // Start main.
 
 }(Date.now(), #)
 }""";
+
+}