Extension method support to move us closer to a valid List implementation.

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 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 24 matching lines @@
 
 bool _isAnnotationType(Annotation m, String name) => m.name.name == name;
 
 Annotation _getAnnotation(AnnotatedNode node, String name) => node.metadata
     .firstWhere((annotation) => _isAnnotationType(annotation, name),
         orElse: () => null);
 
 Annotation _getJsNameAnnotation(AnnotatedNode node) =>
     _getAnnotation(node, "JsName");
 
+// 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;
+
 class JSCodegenVisitor extends GeneralizingAstVisitor with ConversionVisitor {
   final LibraryInfo libraryInfo;
   final TypeRules rules;
 
   // TODO(jmesserly): this is needed because RestrictedTypeRules can send
   // messages to CheckerReporter, for things like missing types.
   // We should probably refactor so this can't happen, as codegen would be too
   // late to be issuing these messages.
   final CheckerReporter _checkerReporter;
 
   /// The variable for the target of the current `..` cascade expression.
   SimpleIdentifier _cascadeTarget;
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   ClassDeclaration currentClass;
   ConstantEvaluator _constEvaluator;
 
-  final _exports = <String>[];
+  final _exports = new Set<String>();
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashSet<String>();
   final _pendingPrivateNames = <String>[];
+  final _extensionMethodNames = new HashSet<String>();
+  final _pendingExtensionMethodNames = <String>[];
+
+  InterfaceType _fillDynamicTypeArgs(InterfaceType t) {
+    var d = rules.provider.dynamicType;
+    return t.substitute4(new List.filled(t.typeArguments.length, d));
+  }
+  // TODO(jacobr): determine the the set of types with extension methods from
+  // the annotations rather than hard coding the list once the analyzer
+  // supports summaries.
+  List<InterfaceType> _jsExtensionMethodTypes;
+  List<InterfaceType> get jsExtensionMethodTypes {
+    if (_jsExtensionMethodTypes != null) return _jsExtensionMethodTypes;
+    _jsExtensionMethodTypes = <InterfaceType>[
+      rules.provider.listType,
+      rules.provider.iterableType
+    ].map(_fillDynamicTypeArgs).toList();
+    return _jsExtensionMethodTypes;
+  }
+
+  Map<ClassElement, Set<String>> _extensionMethods;
+
+  Map<ClassElement, Set<String>> get extensionMethods {
+    if (_extensionMethods != null) return _extensionMethods;
+    _extensionMethods = new HashMap<ClassElement, HashSet<String>>();
+
+    for (var type in jsExtensionMethodTypes) {
+      var names = new HashSet<String>();
+      var e = type.element;
+      names.addAll(e.methods.map((m) => m.name));
+      names.addAll(e.accessors.map((m) => m.name));
+      _extensionMethods[e] = names;
+    }
+    return _extensionMethods;
+  }
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<ClassElement, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<ClassElement, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
@@ skipping 58 matching lines @@
         name,
         name,
         defaultValue
       ])
     ]);
   }
 
   JS.Statement _initPrivateSymbol(String name) => js.statement(
       'let # = $_SYMBOL(#);', [new JSTemporary(name), js.string(name, "'")]);
 
+  JS.Statement _initExtensionMethodSymbol(String name) => js.statement(
+      'let # = $_SYMBOL(#);', [new JS.Identifier(name), js.string(name, "'")]);
+
   // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
   // until we have better name tracking.
   String get _SYMBOL {
     var name = currentLibrary.name;
     if (name == 'dart.core' || name == 'dart._internal') return 'dart.JsSymbol';
     return 'Symbol';
   }
 
   @override
   JS.Statement visitCompilationUnit(CompilationUnit node) {
     var source = node.element.source;
 
     _constEvaluator = new ConstantEvaluator(source, rules.provider);
     _checkerReporter.enterSource(source);
 
     // TODO(jmesserly): scriptTag, directives.
     var body = <JS.Statement>[];
     for (var child in node.declarations) {
       // Attempt to group adjacent fields/properties.
       if (child is! TopLevelVariableDeclaration) _flushLazyFields(body);
       if (child is! FunctionDeclaration) _flushLibraryProperties(body);
 
       var code = _visit(child);
 
       if (code != null) {
         if (_pendingPrivateNames.isNotEmpty) {
           body.addAll(_pendingPrivateNames.map(_initPrivateSymbol));
           _pendingPrivateNames.clear();
         }
+        if (_pendingExtensionMethodNames.isNotEmpty) {
+          body.addAll(
+              _pendingExtensionMethodNames.map(_initExtensionMethodSymbol));
+          _pendingExtensionMethodNames.clear();
+        }
         body.add(code);
       }
     }
 
     // Flush any unwritten fields/properties.
     _flushLazyFields(body);
     _flushLibraryProperties(body);
 
     _checkerReporter.leaveSource();
 
@@ skipping 168 matching lines @@
 
       return js.statement(
           'dart.defineLazyClass(#, { get #() { #; return #; } });', [
         _exportsVar,
         _propertyName(name),
         body,
         name
       ]);
     }
 
-    if (isPublic(name)) _exports.add(name);
+    if (isPublic(name)) _addExport(name);
 
     if (genericDef != null) {
       body = js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
-      if (isPublic(name)) _exports.add(genericName);
+      if (isPublic(name)) _addExport(genericName);
     }
 
     if (classElem.type.isObject) return body;
 
     // If we're not lazy, we still need to ensure our dependencies are
     // generated first.
     var classDefs = <JS.Statement>[];
     _emitClassIfNeeded(classDefs, classElem.supertype.element);
     for (var m in classElem.mixins) {
       _emitClassIfNeeded(classDefs, m.element);
@@ skipping 121 matching lines @@
     if (node.withClause != null) {
       var mixins = _visitList(node.withClause.mixinTypes);
       mixins.insert(0, heritage);
       heritage = js.call('dart.mixin(#)', [mixins]);
     }
     return heritage;
   }
 
   /// Emit class members that can be generated as methods.
   /// Anything not handled here will be addressed in [_finishClassMembers].
+  Iterable<InterfaceType> getMatchingExtensionMethodTypes(InterfaceType type) =>
+      jsExtensionMethodTypes.where((t) => rules.isSubTypeOf(type, t));
+
+  LibraryElement getExtensionLibrary(
+      Iterable<InterfaceType> extensionTypes, String name) {
+    var library = null;
+    for (var type in extensionTypes) {
+      var element = type.element;
+      if (extensionMethods[element].contains(name)) {
+        assert(library == null || library == element.library);
+        library = element.library;
+      }
+    }
+    return library;
+  }
+
+  JS.Expression nameIfExtension(Expression target, String name) {
+    var targetType = rules.getStaticType(target);
+    if (targetType is! InterfaceType) return null;
+    var extensionLibrary =
+        getExtensionLibrary(getMatchingExtensionMethodTypes(targetType), name);
+    if (extensionLibrary == null) return null;
+    return js.call('#.#', [
+      _libraryName(extensionLibrary),
+      _emitExtensionMethodName(name)
+    ]);
+  }
+
   List<JS.Method> _emitClassMethods(ClassDeclaration node,
       List<ConstructorDeclaration> ctors, List<FieldDeclaration> fields) {
     var element = node.element;
     var isObject = element.type.isObject;
     var name = node.name.name;
 
     var jsMethods = <JS.Method>[];
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     if (ctors.isEmpty && !isObject) {
       jsMethods.add(_emitImplicitConstructor(node, name, fields));
     }
-
+    var extensionTypes = getMatchingExtensionMethodTypes(element.type);
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         jsMethods.add(_emitConstructor(member, name, fields, isObject));
       } else if (member is MethodDeclaration) {
-        jsMethods.add(_visit(member));
+        jsMethods.add(_emitMethodDeclaration(member, extensionTypes));
       }
     }
 
     // Support for adapting dart:core Iterator/Iterable to ES6 versions.
     // This lets them use for-of loops transparently.
     // https://github.com/lukehoban/es6features#iterators--forof
     if (element.library.isDartCore && element.name == 'Iterable') {
       JS.Fun body = js.call('''function() {
         var iterator = this.iterator;
         return {
@@ skipping 26 matching lines @@
         new JS.ArrayInitializer(
             classElem.interfaces.map(_emitTypeName).toList())
       ]));
     }
 
     // Named constructors
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null) {
         body.add(js.statement('dart.defineNamedConstructor(#, #);', [
           name,
-          _jsMemberName(member.name.name, isStatic: true)
+          _emitMemberName(member.name.name, isStatic: true)
         ]));
       }
     }
 
     // Static fields
     var lazyStatics = <VariableDeclaration>[];
     for (FieldDeclaration member in staticFields) {
       for (VariableDeclaration field in member.fields.variables) {
         var fieldName = field.name.name;
         if (field.isConst || _isFieldInitConstant(field)) {
@@ skipping 64 matching lines @@
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
     return new JS.Method(name, new JS.Fun(_visit(node.parameters), body))
       ..sourceInformation = node;
   }
 
   JS.Expression _constructorName(String className, SimpleIdentifier name) {
     if (name == null) return js.string(className, "'");
-    return _jsMemberName(name.name, isStatic: true);
+    return _emitMemberName(name.name, isStatic: true);
   }
 
   JS.Block _emitConstructorBody(
       ConstructorDeclaration node, List<FieldDeclaration> fields) {
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     if (node.redirectedConstructor != null) {
       return js.statement('{ return new #(#); }', [
         _visit(node.redirectedConstructor),
         _visit(node.parameters)
       ]);
@@ skipping 90 matching lines @@
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (parameters != null) {
       for (var p in parameters.parameters) {
         if (p is DefaultFormalParameter) p = p.parameter;
         if (p is FieldFormalParameter) {
           var name = p.identifier.name;
           body.add(
-              js.statement('this.# = #;', [_jsMemberName(name), _visit(p)]));
+              js.statement('this.# = #;', [_emitMemberName(name), _visit(p)]));
           unsetFields.remove(name);
         }
       }
     }
 
     // Run constructor field initializers such as `: foo = bar.baz`
     if (initializers != null) {
       for (var init in initializers) {
         if (init is ConstructorFieldInitializer) {
           body.add(js.statement(
               '# = #;', [_visit(init.fieldName), _visit(init.expression)]));
           unsetFields.remove(init.fieldName.name);
         }
       }
     }
 
     // Initialize all remaining fields
     unsetFields.forEach((name, field) {
       JS.Expression value;
       if (field.initializer != null) {
         value = _visit(field.initializer);
       } else {
         var type = rules.elementType(field.element);
         if (rules.maybeNonNullableType(type)) {
           value = js.call('dart.as(null, #)', _emitTypeName(type));
         } else {
           value = new JS.LiteralNull();
         }
       }
-      body.add(js.statement('this.# = #;', [_jsMemberName(name), value]));
+      body.add(js.statement('this.# = #;', [_emitMemberName(name), value]));
     });
 
     return _statement(body);
   }
 
   FormalParameterList _parametersOf(node) {
     // Note: ConstructorDeclaration is intentionally skipped here so we can
     // emit the argument initializers in a different place.
     // TODO(jmesserly): clean this up. If we can model ES6 spread/rest args, we
     // could handle argument initializers more consistently in a separate
@@ skipping 41 matching lines @@
   }
 
   JS.Expression _defaultParamValue(FormalParameter param) {
     if (param is DefaultFormalParameter && param.defaultValue != null) {
       return _visit(param.defaultValue);
     } else {
       return new JS.LiteralNull();
     }
   }
 
-  @override
-  JS.Method visitMethodDeclaration(MethodDeclaration node) {
+  JS.Method _emitMethodDeclaration(
+      MethodDeclaration node, Iterable<InterfaceType> extensionTypes) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
-    return new JS.Method(_jsMemberName(node.name.name, isStatic: node.isStatic),
-        new JS.Fun(params, _visit(node.body)),
+    var memberName;
+    var extensionLibrary;
+
+    if (!node.isStatic) {
+      extensionLibrary = getExtensionLibrary(extensionTypes, node.name.name);
+    }
+
+    if (extensionLibrary != null) {
+      var extensionMethodName = _extensionMethodName(node.name.name);
+      if (extensionLibrary == libraryInfo.library.library) {
+        // 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(extensionMethodName)) {
+          _pendingExtensionMethodNames.add(extensionMethodName);
+          _addExport(extensionMethodName);
+        }
+      }
+      memberName = js.call('#.#', [
+        _libraryName(extensionLibrary),
+        js.string(extensionMethodName, "'")
+      ]);
+    } else {
+      memberName = _emitMemberName(node.name.name, isStatic: node.isStatic);
+    }
+    return new JS.Method(memberName, 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;
 
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
       _properties.add(node);
       return null;
     }
 
     var body = <JS.Statement>[];
     _flushLibraryProperties(body);
 
     var name = node.name.name;
     body.add(js.comment('Function $name: ${node.element.type}'));
 
     body.add(new JS.FunctionDeclaration(
         new JS.Identifier(name), _visit(node.functionExpression)));
 
-    if (isPublic(name)) _exports.add(name);
+    if (isPublic(name)) _addExport(name);
     return _statement(body);
   }
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     return new JS.Method(_propertyName(name), _visit(node.functionExpression),
         isGetter: node.isGetter, isSetter: node.isSetter);
   }
 
   @override
@@ skipping 50 matching lines @@
 
     // library member
     if (e.enclosingElement is CompilationUnitElement &&
         (e.library != libraryInfo.library ||
             variable is TopLevelVariableElement && !variable.isConst)) {
       return js.call('#.#', [_libraryName(e.library), name]);
     }
 
     // instance member
     if (currentClass != null && _needsImplicitThis(e)) {
-      return js.call('this.#', _jsMemberName(name));
+      return js.call('this.#', _emitMemberName(name));
     }
 
     // static member
     if (e is ExecutableElement &&
         e.isStatic &&
         variable.enclosingElement is ClassElement) {
       var className = (variable.enclosingElement as ClassElement).name;
-      return js.call('#.#', [className, _jsMemberName(name, isStatic: true)]);
+      return js.call('#.#', [className, _emitMemberName(name, isStatic: true)]);
     }
 
     // initializing formal parameter, e.g. `Point(this.x)`
     if (e is ParameterElement && e.isInitializingFormal && e.isPrivate) {
       /// Rename private names so they don't shadow the private field symbol.
       /// The renamer would handle this, but it would prefer to rename the
       /// temporary used for the private symbol. Instead rename the parameter.
       return new JSTemporary('${name.substring(1)}');
     }
 
@@ skipping 37 matching lines @@
   }
 
   bool _needQualifiedName(Element element) {
     var lib = element.library;
 
     return lib != null &&
         (lib != currentLibrary ||
             element is ClassElement && _lazyClass(element));
   }
 
-  JS.Node _emitDPutIfDynamic(
+  JS.Node _emitDSetIfDynamic(
       Expression target, SimpleIdentifier id, Expression rhs) {
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.dput(#, #, #)', [
         _visit(target),
         js.string(id.name, "'"),
         _visit(rhs)
       ]);
     } else {
       return null;
     }
   }
 
   @override
   JS.Node visitAssignmentExpression(AssignmentExpression node) {
     var lhs = node.leftHandSide;
     var rhs = node.rightHandSide;
-    return _emitAssignment(lhs, rhs, node.parent);
+    return _emitSet(lhs, rhs, node.parent);
   }
 
-  JS.Node _emitAssignment(Expression lhs, Expression rhs, [AstNode parent]) {
+  JS.Node _emitSet(Expression lhs, Expression rhs, [AstNode parent]) {
     if (lhs is IndexExpression) {
       String code;
       var target = _getTarget(lhs);
       if (rules.isDynamicTarget(target)) {
         code = 'dart.dsetindex(#, #, #)';
-      } else {
-        code = '#.set(#, #)';
+        return js.call(code, [_visit(target), _visit(lhs.index), _visit(rhs)]);
       }
-      return js.call(code, [_visit(target), _visit(lhs.index), _visit(rhs)]);
+      return js.call('#.#(#, #)', [
+        _visit(target),
+        _emitMemberName('[]=', target: target),
+        _visit(lhs.index),
+        _visit(rhs)
+      ]);
     }
 
     if (lhs is PropertyAccess) {
-      var result = _emitDPutIfDynamic(_getTarget(lhs), lhs.propertyName, rhs);
+      var result = _emitDSetIfDynamic(_getTarget(lhs), lhs.propertyName, rhs);
       if (result != null) return result;
     } else if (lhs is PrefixedIdentifier) {
       // TODO(vsm): Is this the right code if the prefix is a library?
-      var result = _emitDPutIfDynamic(lhs.prefix, lhs.identifier, rhs);
+      var result = _emitDSetIfDynamic(lhs.prefix, lhs.identifier, rhs);
       if (result != null) return result;
     }
 
     if (parent is ExpressionStatement &&
         rhs is CascadeExpression &&
         _isStateless(lhs, rhs)) {
       // Special case: cascade assignment to a variable in a statement.
       // We can reuse the variable to desugar it:
       //    result = []..length = length;
       // becomes:
@@ skipping 54 matching lines @@
       } else {
         return js.call('dart.dinvokef(#, #)', [_visit(node.methodName), args]);
       }
     }
 
     // TODO(jmesserly): if this resolves to a getter returning a function with
     // a call method, we don't generate the `.call` correctly.
 
     var targetJs;
     if (target != null) {
-      targetJs = js.call('#.#', [_visit(target), node.methodName.name]);
+      targetJs = js.call('#.#', [
+        _visit(target),
+        _emitMemberName(node.methodName.name, target: target)
+      ]);
     } else {
       targetJs = _visit(node.methodName);
     }
 
     return js.call('#(#)', [targetJs, _visit(node.argumentList)]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
@@ skipping 90 matching lines @@
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     var body = <JS.Statement>[];
 
     for (var field in node.variables.variables) {
       if (field.isConst) {
         // constant fields don't change, so we can generate them as `let`
         // but add them to the module's exports
         var name = field.name.name;
         body.add(js.statement(
             'let # = #;', [new JS.Identifier(name), _visitInitializer(field)]));
-        if (isPublic(name)) _exports.add(name);
+        if (isPublic(name)) _addExport(name);
       } else if (_isFieldInitConstant(field)) {
         body.add(js.statement(
             '# = #;', [_visit(field.name), _visitInitializer(field)]));
       } else {
         _lazyFields.add(field);
       }
     }
 
     return _statement(body);
   }
 
+  _addExport(String name) {
+    if (!_exports.add(name)) throw 'Duplicate top level name found: $name';
+  }
+
   @override
   visitVariableDeclarationList(VariableDeclarationList node) {
     var last = node.variables.last;
     var lastInitializer = last.initializer;
 
     List<JS.VariableInitialization> variables;
     if (lastInitializer is CascadeExpression &&
         node.parent is VariableDeclarationStatement) {
       // Special case: cascade as variable initializer
       //
@@ skipping 74 matching lines @@
   @override
   JS.Statement visitVariableDeclarationStatement(
           VariableDeclarationStatement node) =>
       _expressionStatement(_visit(node.variables));
 
   @override
   visitConstructorName(ConstructorName node) {
     var typeName = _visit(node.type);
     if (node.name != null) {
       return js.call(
-          '#.#', [typeName, _jsMemberName(node.name.name, isStatic: true)]);
+          '#.#', [typeName, _emitMemberName(node.name.name, isStatic: true)]);
     }
     return typeName;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     return js.call(
         'new #(#)', [_visit(node.constructorName), _visit(node.argumentList)]);
   }
 
@@ skipping 177 matching lines @@
   JS.Expression _emitPostfixIncrement(Expression expr, Token op) {
     var type = rules.getStaticType(expr);
     assert(type != null);
     var tmp = _createTemporary('x', type);
 
     // Increment and write
     var one = AstBuilder.integerLiteral(1);
     one.staticType = rules.provider.intType;
     var increment = AstBuilder.binaryExpression(tmp, op.lexeme[0], one);
     increment.staticType = type;
-    var write = _emitAssignment(expr, increment);
+    var write = _emitSet(expr, increment);
 
     var bindThis = _maybeBindThis(expr);
     return js.call("((#) => (#, #))$bindThis(#)", [
       _visit(tmp),
       write,
       _visit(tmp),
       _visit(expr)
     ]);
   }
 
@@ skipping 15 matching lines @@
     }
 
     assert(op.lexeme == '++' || op.lexeme == '--');
     return _emitPostfixIncrement(expr, op);
   }
 
   JS.Expression _emitPrefixIncrement(Token op, Expression expr) {
     var one = AstBuilder.integerLiteral(1);
     one.staticType = rules.provider.intType;
     var increment = AstBuilder.binaryExpression(expr, op.lexeme[0], one);
-    return _emitAssignment(expr, increment);
+    return _emitSet(expr, increment);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     return _emitPrefixExpression(node.operator, node.operand);
   }
 
   JS.Expression _emitPrefixExpression(Token op, Expression expr) {
     var dispatchType = rules.getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('$op#', _visit(expr));
       } else if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
         var mathop = op.lexeme[0];
         return js.call('# = # $mathop 1', [_visit(expr), notNull(expr)]);
       } else {
         return js.call('$op#', notNull(expr));
       }
     } else {
       // Increment or decrement requires expansion.
       if (op.lexeme == '++' || op.lexeme == '--') {
         return _emitPrefixIncrement(op, expr);
       }
     }
 
     // Call the operator
-    var opString = _jsMemberName(op.lexeme, unary: true);
+    var opString = _emitMemberName(op.lexeme, unary: true);
     if (rules.isDynamicTarget(expr)) {
       // dynamic dispatch
       return js.call('dart.dunary(#, #)', [opString, _visit(expr)]);
     } else if (_isJSBuiltinType(dispatchType)) {
       return js.call(
           '#.#(#)', [_emitTypeName(dispatchType), opString, _visit(expr)]);
     } else {
       // Generic static-dispatch, user-defined operator code path.
       return js.call('#.#()', [_visit(expr), opString]);
     }
@@ skipping 79 matching lines @@
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.prefix.staticElement is PrefixElement) {
       return _visit(node.identifier);
     } else {
-      return _visitGet(node.prefix, node.identifier);
+      return _emitGet(node.prefix, node.identifier);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
-      _visitGet(_getTarget(node), node.propertyName);
+      _emitGet(_getTarget(node), node.propertyName);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
-  _visitGet(Expression target, SimpleIdentifier name) {
+  _emitGet(Expression target, SimpleIdentifier name) {
     if (rules.isDynamicTarget(target)) {
       return js.call(
           'dart.dload(#, #)', [_visit(target), js.string(name.name, "'")]);
     } else {
       var e = name.staticElement;
-      return js.call('#.#', [
+      var ret = js.call('#.#', [
         _visit(target),
-        _jsMemberName(name.name, isStatic: e is ExecutableElement && e.isStatic)
+        _emitMemberName(name.name,
+            isStatic: e is ExecutableElement && e.isStatic, target: target)
       ]);
+      return ret;
     }
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
-    var code;
     if (rules.isDynamicTarget(target)) {
-      code = 'dart.dindex(#, #)';
-    } else {
-      code = '#.get(#)';
+      return js.call('dart.dindex(#, #)', [_visit(target), _visit(node.index)]);
     }
-    return js.call(code, [_visit(target), _visit(node.index)]);
+
+    return js.call('#.#(#)', [
+      _visit(target),
+      _emitMemberName('[]', target: target),
+      _visit(node.index)
+    ]);
   }
 
   /// Gets the target of a [PropertyAccess] or [IndexExpression].
   /// Those two nodes are special because they're both allowed on left side of
   /// an assignment expression and cascades.
   Expression _getTarget(node) {
     assert(node is IndexExpression || node is PropertyAccess);
     return node.isCascaded ? _cascadeTarget : node.target;
   }
 
@@ skipping 365 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 _jsMemberName(String name,
-      {bool unary: false, bool isStatic: false}) {
+  JS.Expression _emitMemberName(String name,
+      {bool unary: false, bool isStatic: false, Expression target}) {
+    if (isStatic == false && target != null) {
+      var ret = nameIfExtension(target, name);
+      if (ret != null) return ret;
+    }
     if (name.startsWith('_')) {
       if (_privateNames.add(name)) _pendingPrivateNames.add(name);
       return new JSTemporary(name);
     }
-    if (name == '[]') {
-      name = 'get';
-    } else if (name == '[]=') {
-      name = 'set';
-    } else if (unary && name == '-') {
-      name = 'unary-';
-    } else if (isStatic && invalidJSStaticMethodName(name)) {
+    return _propertyName(_jsMemberName(name, unary: unary, isStatic: isStatic));
+  }
+
+  String _jsMemberName(String name, {bool unary: false, bool isStatic: false}) {
+    if (name == '[]') return 'get';
+    if (name == '[]=') return 'set';
+    if (unary && name == '-') return 'unary-';
+    if (isStatic && invalidJSStaticMethodName(name)) {
       // Choose an string name. Use an invalid identifier so it won't conflict
       // with any valid member names.
       // TODO(jmesserly): this works around the problem, but I'm pretty sure we
       // don't need it, as static methods seemed to work. The only concrete
       // issue we saw was in the defineNamedConstructor helper function.
-      name = '$name*';
+      return '$name*';
     }
-    return _propertyName(name);
+    return name;
   }
 
+  JS.LiteralString _emitExtensionMethodName(String name) =>
+      js.string(_extensionMethodName(name), "'");
+
+  String _extensionMethodName(String name) => '\$${_jsMemberName(name)}';
+
   bool _externalOrNative(node) =>
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
   JS.Identifier _libraryName(LibraryElement library) {
@@ skipping 208 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }