fuse List and js Array together and a few other misc fixes.

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;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 256 matching lines @@
     var type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
 
     var name = type.name;
     var result = js.statement('let # = dart.typedef(#, () => #);', [
       new JS.Identifier(name),
       js.string(name, "'"),
       _emitTypeName(node.element.type, lowerTypedef: true)
     ]);
 
-    return _finishClassDef(type, result);
+    return _finishClassDef(type, result, null);
   }
 
   @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 type = node.element.type;
     if (_pendingClasses.remove(node.element) == null) return null;
 
     var name = node.name.name;
     var heritage =
         js.call('dart.mixin(#)', [_visitList(node.withClause.mixinTypes)]);
     var classDecl = new JS.ClassDeclaration(
         new JS.ClassExpression(new JS.Identifier(name), heritage, []));
 
-    return _finishClassDef(type, classDecl);
+    return _finishClassDef(type, classDecl, null);
   }
 
   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;
     if (_pendingClasses.remove(classElem) == null) return null;
 
     var jsName = getAnnotationValue(node, _isJsNameAnnotation);
+
     if (jsName != null) return _emitJsType(node.name.name, jsName);
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       }
     }
 
     var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(node), _emitClassMethods(node, ctors, fields));
 
     var body =
         _finishClassMembers(classElem, classExpr, ctors, fields, staticFields);
 
-    return _finishClassDef(type, body);
+    var jsPeer = getAnnotationValue(node, _isJsPeerInterface);
+    String jsPeerName = null;
+    if (jsPeer != null) {
+      jsPeerName = getConstantField(jsPeer, 'name', types.stringType);
+    }
+
+    return _finishClassDef(type, body, jsPeerName);
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) =>
       _unimplementedCall("Unimplemented enum: $node").toStatement();
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
   /// and ensuring dependencies are loaded first.
-  JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
+  JS.Statement _finishClassDef(
+      ParameterizedType type, JS.Statement body, String jsPeerName) {
     var name = type.name;
     var genericName = '$name\$';
 
     JS.Statement genericDef;
     JS.Expression genericInst;
     if (type.typeParameters.isNotEmpty) {
       genericDef = _emitGenericClassDef(type, body);
       var target = genericName;
       if (_needQualifiedName(type.element)) {
         target = js.call('#.#', [_exportsVar, genericName]);
@@ skipping 38 matching lines @@
     var classDefs = <JS.Statement>[];
     if (type is InterfaceType) {
       _emitClassIfNeeded(classDefs, type.superclass);
       for (var m in type.element.mixins) {
         _emitClassIfNeeded(classDefs, m);
       }
     } else if (type is FunctionType) {
       _emitClassIfNeeded(classDefs, types.functionType);
     }
     classDefs.add(body);
+    if (jsPeerName != null) {
+      classDefs.add(js.statement(
+          'dart.copyProperties(dart.global.#.prototype, #.prototype);', [
+        _propertyName(jsPeerName),
+        name
+      ]));
+    }
     return _statement(classDefs);
   }
 
   void _emitClassIfNeeded(List<JS.Statement> defs, DartType base) {
     // We can only emit classes from this library.
     if (base.element.library != currentLibrary) return;
 
     var baseNode = _pendingClasses[base.element];
     if (baseNode != null) defs.add(visitClassDeclaration(baseNode));
   }
@@ skipping 1908 matching lines @@
   JS.Expression _extensionMethodName(String name, LibraryElement library) {
     var extName = '\$$name';
     if (library == currentLibrary) {
       // TODO(jacobr): need to do a better job ensuring that extension method
       // name symbols do not conflict with other symbols before we can let
       // user defined libraries define extension methods.
       if (_extensionMethodNames.add(extName)) {
         _pendingSymbols.add(new JS.Identifier(extName));
         _addExport(extName);
       }
+      return new JS.Identifier(extName);
     }
     return js.call('#.#', [_libraryName(library), _propertyName(extName)]);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
@@ skipping 72 matching lines @@
     assert(uri.scheme == 'package');
     // filepath is good here, we want the output to start with a directory
     // matching the package name.
   }
   return filepath;
 }
 
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
+bool _isJsPeerInterface(DartObjectImpl value) =>
+    value.type.name == 'JsPeerInterface';
+
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;