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 540 matching lines @@
       ]));
     }
 
     // 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, declaration: true));
+      }
+      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),
+    return new JS.Method(_elementMemberName(node.element, declaration: true),
         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);
 
@@ skipping 1455 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 declaration: false}) {
     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);
+        declaration: declaration);
   }
 
   /// 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 43 matching lines @@
 
     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)) {
-      // Special case `length`. We can call it directly.
-      if (name != 'length') return js.call('dartx.#', _propertyName(name));
+    // Special case `length`. We can call it directly.
+    if (_extensionTypes.contains(type.element) && name != 'length') {
+      var code = declaration ? 'dart.extensionMember(#)' : 'dartx.#';
+      return js.call(code, _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
@@ skipping 84 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);
 }