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) {
+        assert(() {

[kasperl, 2014/11/27 09:05:14]

Add a comment for the assert. What are you verifying? It might be easier to
diagnose assertion failures if you split these out as separate asserts, but I
understand that you prefer not to have the mixinApplication variable introduced
outside the asserts. Maybe using an 'as' cast in an assert would be okay?

[floitsch, 2014/11/27 12:35:16]

Reduced the assert.
It is now just testing that mixins don't introduce new fields.
The fields and methods are empty by construction (in the constructor), so it is
redundant to check it here. And I'm not too afraid that refactorings would
change that.

done.

+          if (currentClass.isMixinApplication) {
+            if (currentClass.fields.isNotEmpty) return false;
+            if (currentClass.methods.isNotEmpty) return false;
+            MixinApplication mixinApplication = currentClass;
+            if (mixinApplication.mixinClass.fields.isNotEmpty) return false;
+          }
+          return true;
+        });
+
+        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) {
+    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 ]));

[sigurdm, 2014/11/27 09:25:54]

Space inside the '['

[floitsch, 2014/11/27 12:35:16]

Done.

     return unparse(compiler, new js.ArrayInitializer.from(elements));
   }
 
+  static final String mixinFormatComment =
+      "Mixins have no constructor, but a reference to their mixin class.";

[sigurdm, 2014/11/27 09:25:54]

Empty line between members.

[floitsch, 2014/11/27 12:35:16]

Done.

+  js.Expression emitMixinApplication(MixinApplication cls) {
+    List elements = [ js.string(cls.superclassName),

[sigurdm, 2014/11/27 09:25:54]

Space inside the '['

[floitsch, 2014/11/27 12:35:16]

Done.

+                      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);
+    // $mixinFormatComment.

[floitsch, 2014/11/26 17:32:09]

I'm using this "marker" as a way to easily find all references of the
mixin-format, and to find the format-specification from its uses.

[sigurdm, 2014/11/27 09:25:54]

Perhaps also explain that in a comment in the code.

[floitsch, 2014/11/27 12:35:16]

Done.

+    if (typeof descriptor[2] !== 'function') {

[sigurdm, 2014/11/27 09:25:54]

Could there be a less fragile way of distinguishing mixins from other classes?

[floitsch, 2014/11/27 12:35:16]

I don't see any, that wouldn't require bigger changes, or that would waste
space.

+      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) {
+    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(), #)
 }""";
+
+}