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 311 matching lines @@
     ]);
 
     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.

[vsm, 2015/06/19 23:20:40]

Is this comment still valid?

[Jennifer Messerly, 2015/06/22 15:55:44]

Good catch, removed (from 3 places!)

     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.#(...#); }', [

[vsm, 2015/06/19 23:20:40]

It'd be nice to have the args here to show the actual API.

[Jennifer Messerly, 2015/06/22 15:55:44]

Agreed. However, there are a few reasons for not doing that:
* we don't have a FormalParameterList here, just the element model, so can't
reuse existing visit* code.
* we don't have an ArgumentList, so we'd have to emit parameters in argument
position. Happens to be valid at the moment, probably won't be when we have
destructuring.
* it's less error prone to do forward all arguments this way. It avoids obscure
bugs that could happen, like "default value is incorrect in mixin application
constructor super calls" or "named arguments don't work in mixin application" :)

In the very long term I'm in favor of this kind of readability tweak, but I
think we have a lot of higher priority things to do first.

+          _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.
@@ skipping 2443 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);
 }