fixes browser/runtime_test, and a few extension member 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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 523 matching lines @@
 
   /// Emit class members that need to come after the class declaration, such
   /// as static fields. See [_emitClassMethods] for things that are emitted
   /// inside the ES6 `class { ... }` node.
   JS.Statement _finishClassMembers(ClassElement classElem,
       JS.ClassExpression cls, List<ConstructorDeclaration> ctors,
       List<FieldDeclaration> fields, List<MethodDeclaration> methods,
       String jsPeerName) {
     var name = classElem.name;
     var body = <JS.Statement>[];
+
+    if (jsPeerName != null) {
+      var dartxNames = [];
+      for (var m in methods) {
+        if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
+          dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
+        }
+      }
+      body.add(js.statement('dart.defineExtensionNames(#)',
+          [new JS.ArrayInitializer(dartxNames, multiline: true)]));
+    }
+
     body.add(new JS.ClassDeclaration(cls));
 
     // TODO(jmesserly): we should really just extend native Array.
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
       body.add(js.statement('dart.setBaseClass(#, dart.global.#);', [
         classElem.name,
         _propertyName(jsPeerName)
       ]));
     }
 
     // Interfaces
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         name,
         new JS.ArrayInitializer(
             classElem.interfaces.map(_emitTypeName).toList())
       ]));
-
-      // If a concrete class implements one of our extensions, we might need to
-      // add forwarders.
-      var extensions = _extensionsToImplement(classElem);
-      if (extensions.isNotEmpty) {
-        var methodNames = [];
-        for (var e in extensions) {
-          methodNames.add(_emitMemberDeclarationName(e));
-        }
-        body.add(js.statement('dart.defineExtensionMembers(#, #);', [
-          name,
-          new JS.ArrayInitializer(methodNames,
-              multiline: methodNames.length > 4)
-        ]));
-      }
     }
 
     // Named constructors
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
         body.add(js.statement('dart.defineNamedConstructor(#, #);', [
           name,
           _emitMemberName(member.name.name, isStatic: true)
         ]));
       }
@@ skipping 15 matching lines @@
       var tMethods = [];
       var sNames = [];
       for (MethodDeclaration node in methods) {
         if (!(node.isSetter || node.isGetter || node.isAbstract)) {
           var name = node.name.name;
           var element = node.element;
           var inheritedElement =
               classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
           if (inheritedElement != null &&
               inheritedElement.type == element.type) continue;
-          var memberName = _emitMemberDeclarationName(element);
+          var memberName = _elementMemberName(element);
           var parts =
               _emitFunctionTypeParts(element.type, dynamicIsBottom: false);
           var property =
               new JS.Property(memberName, new JS.ArrayInitializer(parts));
           if (node.isStatic) {
             tStatics.add(property);
             sNames.add(memberName);
           } else {
             tMethods.add(property);
           }
@@ skipping 26 matching lines @@
         sigFields.add(build('statics', tStatics));
         sigFields.add(aNames);
       }
       if (!sigFields.isEmpty) {
         var sig = new JS.ObjectInitializer(sigFields);
         var classExpr = new JS.Identifier(name);
         body.add(js.statement('dart.setSignature(#, #);', [classExpr, sig]));
       }
     }
 
+    // If a concrete class implements one of our extensions, we might need to
+    // add forwarders.
+    var extensions = _extensionsToImplement(classElem);
+    if (extensions.isNotEmpty) {
+      var methodNames = [];
+      for (var e in extensions) {
+        methodNames.add(_elementMemberName(e));
+      }
+      body.add(js.statement('dart.defineExtensionMembers(#, #);', [
+        name,
+        new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
+      ]));
+    }
+
     return _statement(body);
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
     if (_extensionTypes.contains(element)) return members;
 
     // Collect all extension types we implement.
     var type = element.type;
     var types = new Set<ClassElement>();
@@ skipping 373 matching lines @@
   }
 
   JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
-    return new JS.Method(_emitMemberDeclarationName(node.element),
-        new JS.Fun(params, _visit(node.body)),
+    return new JS.Method(
+        _elementMemberName(node.element), new JS.Fun(params, _visit(node.body)),
         isGetter: node.isGetter,
         isSetter: node.isSetter,
         isStatic: node.isStatic);
   }
 
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
@@ skipping 1475 matching lines @@
   /// Visits a list of expressions, creating a comma expression if needed in JS.
   JS.Expression _visitListToBinary(List<Expression> nodes, String operator) {
     if (nodes == null || nodes.isEmpty) return null;
     return new JS.Expression.binary(_visitList(nodes), operator);
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
-  JS.Expression _emitMemberDeclarationName(ExecutableElement e) {
+  JS.Expression _elementMemberName(ExecutableElement e,
+      {bool allowExtensions: true}) {
     String name;
     if (e is PropertyAccessorElement) {
       name = e.variable.name;
     } else {
       name = e.name;
     }
     return _emitMemberName(name,
         type: (e.enclosingElement as ClassElement).type,
         unary: e.parameters.isEmpty,
         isStatic: e.isStatic,
-        declaration: true);
+        allowExtensions: allowExtensions);
   }
 
   /// This handles member renaming for private names and operators.
   ///
   /// Private names are generated using ES6 symbols:
   ///
   ///     // At the top of the module:
   ///     let _x = Symbol('_x');
   ///     let _y = Symbol('_y');
   ///     ...
@@ skipping 24 matching lines @@
   /// This follows the same pattern as EcmaScript 6 Map:
   /// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map>
   ///
   /// Unary minus looks like: `x['unary-']()`. Note that [unary] must be passed
   /// for this transformation to happen, otherwise binary minus is assumed.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
   ///
   JS.Expression _emitMemberName(String name, {DartType type, bool unary: false,
-      bool isStatic: false, bool declaration: false}) {
+      bool isStatic: false, bool allowExtensions: true}) {
 
     // Static members skip the rename steps.
     if (isStatic) return _propertyName(name);
 
     if (name.startsWith('_')) {
       return _privateNames.putIfAbsent(
           name, () => _initSymbol(new JS.TemporaryId(name)));
     }
 
     if (name == '[]') {
       name = 'get';
     } else if (name == '[]=') {
       name = 'set';
     } else if (name == '-' && unary) {
       name = 'unary-';
     }
 
     // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
-    if (!declaration && _extensionTypes.contains(type.element)) {
+    if (allowExtensions && _extensionTypes.contains(type.element)) {
       // Special case `length`. We can call it directly.
       if (name != 'length') return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
@@ skipping 86 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);
 }