dart2js: add constructor for directly instatiated mixin classes 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 '../../dart_types.dart' show DartType;
 import '../../elements/elements.dart' show ClassElement;
 import '../../js/js.dart' as js;
@@ skipping 15 matching lines @@
     IS_HUNK_LOADED,
     LEAF_TAGS,
     MANGLED_GLOBAL_NAMES,
     METADATA,
     TYPE_TO_INTERCEPTOR_MAP;
 
 import '../js_emitter.dart' show NativeGenerator, buildTearOffCode;
 import '../model.dart';
 
 
-
 class ModelEmitter {
   final Compiler compiler;
   final Namer namer;
   final ConstantEmitter constantEmitter;
   final NativeEmitter nativeEmitter;
 
   JavaScriptBackend get backend => compiler.backend;
 
   /// For deferred loading we communicate the initializers via this global var.
   static const String deferredInitializersGlobal =
@@ skipping 412 matching lines @@
     Iterable<Method> setters = cls.fields
         .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.";
+      "Mixins have a reference to their mixin class at the place of the usual"
+      "constructor. If they are instantiated the constructor follows the"
+      "reference.";
 
   js.Expression emitClass(Class cls) {
     List elements = [js.string(cls.superclassName),
                      js.number(cls.superclassHolderIndex)];
 
     if (cls.isMixinApplication) {
       MixinApplication mixin = cls;
       elements.add(js.string(mixin.mixinClass.name));
       elements.add(js.number(mixin.mixinClass.holder.index));
+      if (cls.isDirectlyInstantiated) {
+        elements.add(_generateConstructor(cls));
+      }
     } else {
       elements.add(_generateConstructor(cls));
     }
     Iterable<Method> methods = cls.methods;
     Iterable<Method> isChecks = cls.isChecks;
     Iterable<Method> callStubs = cls.callStubs;
     Iterable<Method> noSuchMethodStubs = cls.noSuchMethodStubs;
     Iterable<Method> gettersSetters = _generateGettersSetters(cls);
     Iterable<Method> allMethods =
         [methods, isChecks, callStubs, noSuchMethodStubs, gettersSetters]
@@ skipping 304 matching lines @@
   }
 
   #tearOff;
 
   #parseFunctionDescriptor;
 
   function compileConstructor(name, descriptor) {
     descriptor = compile(name, descriptor);
     var prototype = determinePrototype(descriptor);
     var constructor;
+    var functionsIndex;
     // $mixinFormatDescription.
     if (typeof descriptor[2] !== 'function') {
-      constructor = compileMixinConstructor(name, prototype, descriptor);
-      for (var i = 4; i < descriptor.length; i += 2) {
-        parseFunctionDescriptor(prototype, descriptor[i], descriptor[i + 1]);
+      fillPrototypeWithMixedIn(descriptor[2], descriptor[3], prototype);
+      // descriptor[4] contains the constructor if the mixin application is
+      // directly instantiated.
+      if (typeof descriptor[4] === 'function') {
+        constructor = descriptor[4];
+        functionsIndex = 5;
+      } else {
+        constructor = function() {};
+        functionsIndex = 4;
       }
     } else {
       constructor = descriptor[2];
-      for (var i = 3; i < descriptor.length; i += 2) {
-        parseFunctionDescriptor(prototype, descriptor[i], descriptor[i + 1]);
-      }
+      functionsIndex = 3;
     }
+
+    for (var i = functionsIndex; i < descriptor.length; i += 2) {
+      parseFunctionDescriptor(prototype, descriptor[i], descriptor[i + 1]);
+    }
+
     constructor.builtin\$cls = name;  // Needed for RTI.
     constructor.prototype = prototype;
     prototype[#operatorIsPrefix + name] = constructor;
     prototype.constructor = constructor;
     return constructor;
   }
 
-  function compileMixinConstructor(name, prototype, descriptor) {
-    // $mixinFormatDescription.
-    var mixinName = descriptor[2];
-    var mixinHolderIndex = descriptor[3];
+  function fillPrototypeWithMixedIn(mixinName, mixinHolderIndex, prototype) {
     var mixin = holders[mixinHolderIndex][mixinName].ensureResolved();
     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() {};
-    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].ensureResolved();
 
@@ skipping 57 matching lines @@
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
   #main();  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }