fixes #231, mixin application (aka ClassTypeAlias) implicit ctors

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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 dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 292 matching lines @@
 
   String _jsTypeofName(DartType t) {
     if (rules.isIntType(t) || rules.isDoubleType(t)) return 'number';
     if (rules.isStringType(t)) return 'string';
     if (rules.isBoolType(t)) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
-    // If we've already emitted this class, skip it.
     var element = node.element;
     var type = element.type;
     var name = element.name;
 
     var fnType = js.statement('let # = dart.typedef(#, () => #);', [
       name,
       js.string(name, "'"),
       _emitTypeName(type, lowerTypedef: true)
     ]);
 
     return _finishClassDef(type, fnType);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
-    // If we've already emitted this class, skip it.
     var element = node.element;
 
+    // Forward all generative constructors from the base class.
+    var body = [];
+
+    var supertype = element.supertype;
+    if (!supertype.isObject) {
+      for (var ctor in element.constructors) {
+        var parentCtor = supertype.lookUpConstructor(ctor.name, ctor.library);
+        var fun = js.call('function() { super.#(...#); }', [
+          _constructorName(parentCtor),
+          new JS.Identifier('arguments', allowRename: false)
+        ]);
+        body.add(new JS.Method(_constructorName(ctor), fun));
+      }
+    }
+
     var classDecl = new JS.ClassDeclaration(new JS.ClassExpression(
-        new JS.Identifier(element.name), _classHeritage(element), []));
+        new JS.Identifier(element.name), _classHeritage(element), body));
 
     return _finishClassDef(element.type, classDecl);
   }
 
   JS.Statement _emitJsType(String dartClassName, DartObjectImpl jsName) {
     var jsTypeName = getConstantField(jsName, 'name', types.stringType);
 
     if (jsTypeName != null && jsTypeName != dartClassName) {
       // We export the JS type as if it was a Dart type. For example this allows
       // `dom.InputElement` to actually be HTMLInputElement.
       // TODO(jmesserly): if we had the JsName on the Element, we could just
       // generate it correctly when we refer to it.
       if (isPublic(dartClassName)) _addExport(dartClassName);
       return js.statement('let # = #;', [dartClassName, jsTypeName]);
     }
     return null;
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
-    // If we've already emitted this class, skip it.
     var classElem = node.element;
     var type = classElem.type;
     var jsName = findAnnotation(classElem, _isJsNameAnnotation);
 
     if (jsName != null) return _emitJsType(node.name.name, jsName);
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
     for (var member in node.members) {
@@ skipping 2422 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }