Fix for #29003

pkg/dev_compiler/lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 698 matching lines @@
       // that throws instead?
       assert(options.unsafeForceCompile || options.replCompile);
       return _callHelper('dynamic');
     }
     return _emitType(node.type);
   }
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
+    var supertype = element.supertype;
 
     // Forward all generative constructors from the base class.
     var methods = <JS.Method>[];
-
-    var supertype = element.supertype;
     if (!supertype.isObject) {
       for (var ctor in element.constructors) {
         var parentCtor = supertype.lookUpConstructor(ctor.name, ctor.library);
         // TODO(jmesserly): this avoids spread args for perf. Revisit.
         var jsParams = <JS.Identifier>[];
         for (var p in ctor.parameters) {
           if (p.parameterKind != ParameterKind.NAMED) {
             jsParams.add(new JS.Identifier(p.name));
           } else {
             jsParams.add(new JS.TemporaryId('namedArgs'));
             break;
           }
         }
         var fun = js.call('function(#) { super.#(#); }',
             [jsParams, _constructorName(parentCtor), jsParams]) as JS.Fun;
         methods.add(new JS.Method(_constructorName(ctor), fun));
       }
     }
 
+    var typeFormals = element.typeParameters;
+    var isGeneric = typeFormals.isNotEmpty;
+    var className = isGeneric ? element.name : _emitTopLevelName(element);
+    JS.Statement declareInterfaces(JS.Statement decl) {
+      if (element.interfaces.isNotEmpty) {
+        var body = [decl]
+          ..add(js.statement('#[#.implements] = () => #;', [
+            className,
+            _runtimeModule,
+            new JS.ArrayInitializer(
+                new List<JS.Expression>.from(element.interfaces.map(_emitType)))
+          ]));
+        decl = _statement(body);
+      }
+      return decl;
+    }
+
+    if (supertype.isObject && element.mixins.length == 1) {
+      // Special case where supertype is Object, and we mixin a single class.
+      // The resulting 'class' is a mixable class in this case.
+      var classExpr = _emitClassHeritage(element);
+      if (isGeneric) {
+        var classStmt = js.statement('const # = #;', [className, classExpr]);
+        return _defineClassTypeArguments(
+            element, typeFormals, declareInterfaces(classStmt));
+      } else {
+        var classStmt = js.statement('# = #;', [className, classExpr]);
+        return declareInterfaces(classStmt);
+      }
+    }
+
     var classExpr = _emitClassExpression(element, methods);
-
-    var typeFormals = element.typeParameters;
-    if (typeFormals.isNotEmpty) {
+    if (isGeneric) {
+      var classStmt = new JS.ClassDeclaration(classExpr);
       return _defineClassTypeArguments(
-          element, typeFormals, new JS.ClassDeclaration(classExpr));
+          element, typeFormals, declareInterfaces(classStmt));
     } else {
-      return js.statement('# = #;', [_emitTopLevelName(element), classExpr]);
+      var classStmt = js.statement('# = #;', [className, classExpr]);
+      return declareInterfaces(classStmt);
     }
   }
 
   JS.Statement _emitJsType(Element e) {
     var jsTypeName = getAnnotationName(e, isJSAnnotation);
     if (jsTypeName == null || jsTypeName == e.name) return null;
 
     // 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 JS name on the Element, we could just
@@ skipping 5276 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }