refactor emitMemberName to be used more consistently

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;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart'
     show StringToken, Token, TokenType;
 import 'package:source_maps/source_maps.dart' as srcmaps show Printer;
 import 'package:source_maps/source_maps.dart' show SourceMapSpan;
 import 'package:source_span/source_span.dart' show SourceLocation;
 import 'package:path/path.dart' as path;
 
 import 'package:dev_compiler/src/codegen/ast_builder.dart' show AstBuilder;
 
 // TODO(jmesserly): import from its own package
@@ skipping 20 matching lines @@
 
 // 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;
 
+  /// The global extension method table.
+  final HashMap<String, List<InterfaceType>> _extensionMethods;
+
   /// 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 = 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;
-  }
+  /// The name for the library's exports inside itself.
+  /// This much be a constant because we interpolate it into template strings,
+  /// and otherwise it would break caching for them.
+  /// `exports` was chosen as the most similar to ES module patterns.
+  final JSTemporary _exportsVar = new JSTemporary('exports');
+  final JSTemporary _namedArgTemp = new JSTemporary('opts');
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
   final _pendingClasses = new HashMap<Element, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
   final _lazyClassMemo = new HashMap<Element, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
-  JSCodegenVisitor(this.libraryInfo, this.rules);
+  JSCodegenVisitor(this.libraryInfo, this.rules, this._extensionMethods);
 
   LibraryElement get currentLibrary => libraryInfo.library;
-
-  /// The name for the library's exports inside itself.
-  /// This much be a constant because we interpolate it into template strings,
-  /// and otherwise it would break caching for them.
-  /// `exports` was chosen as the most similar to ES module patterns.
-  final JSTemporary _exportsVar = new JSTemporary('exports');
-  final JSTemporary _namedArgTemp = new JSTemporary('opts');
+  TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     var jsDefaultValue = '{}';
     var unit = library.library;
     if (unit.directives.isNotEmpty) {
       var annotation = _getJsNameAnnotation(unit.directives.first);
       if (annotation != null) {
         var arguments = annotation.arguments.arguments;
         if (!arguments.isEmpty) {
           var namedExpression = arguments.first as NamedExpression;
@@ skipping 54 matching lines @@
   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);
+    _constEvaluator = new ConstantEvaluator(source, types);
 
     // 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);
 
@@ skipping 197 matching lines @@
     // The base class and all mixins must be declared before this class.
     if (_lazyClass(type)) {
       // TODO(jmesserly): the lazy class def is a simple solution for now.
       // We may want to consider other options in the future.
 
       if (genericDef != null) {
         return js.statement(
             '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }', [
           genericDef,
           _exportsVar,
-          js.string(name, "'"),
+          _propertyName(name),
           genericName
         ]);
       }
 
       return js.statement(
           'dart.defineLazyClass(#, { get #() { #; return #; } });', [
         _exportsVar,
         _propertyName(name),
         body,
         name
@@ skipping 10 matching lines @@
 
     // If we're not lazy, we still need to ensure our dependencies are
     // generated first.
     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, rules.provider.functionType);
+      _emitClassIfNeeded(classDefs, types.functionType);
     }
     classDefs.add(body);
     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));
   }
 
   /// Returns true if the supertype or mixins aren't loaded.
   /// If that is the case, we'll emit a lazy class definition.
   bool _lazyClass(DartType type) {
     if (type.isObject) return false;
 
     // Use the element as the key, as those are unique whereas generic types
     // can have their arguments substituted.
     assert(type.element.library == currentLibrary);
     var result = _lazyClassMemo[type.element];
     if (result != null) return result;
 
     if (type is InterfaceType) {
       result = _typeMightNotBeLoaded(type.superclass) ||
           type.mixins.any(_typeMightNotBeLoaded);
     } else if (type is FunctionType) {
-      result = _typeMightNotBeLoaded(rules.provider.functionType);
+      result = _typeMightNotBeLoaded(types.functionType);
     }
     return _lazyClassMemo[type.element] = result;
   }
 
   /// Curated order to minimize lazy classes needed by dart:core and its
   /// transitive SDK imports.
   static const CORELIB_ORDER = const [
     'dart.core',
     'dart.collection',
     'dart._internal'
@@ skipping 75 matching lines @@
     ]);
   }
 
   JS.Expression _classHeritage(ClassDeclaration node) {
     if (node.element.type.isObject) return null;
 
     JS.Expression heritage = null;
     if (node.extendsClause != null) {
       heritage = _visit(node.extendsClause.superclass);
     } else {
-      heritage = _emitTypeName(rules.provider.objectType);
+      heritage = _emitTypeName(types.objectType);
     }
     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 type = element.type;
+    var isObject = 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(_emitMethodDeclaration(member, extensionTypes));
+        jsMethods.add(_emitMethodDeclaration(type, member));
       }
     }
 
     // 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 86 matching lines @@
         node.name == null) {
       // Implements Dart constructor behavior. Because of V8 `super`
       // [constructor restrictions]
       // (https://code.google.com/p/v8/issues/detail?id=3330#c65)
       // we cannot currently emit actual ES6 constructors with super calls.
       // Instead we use the same trick as named constructors, and do them as
       // instance methods that perform initialization.
       // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
       // settles. See <https://github.com/dart-lang/dev_compiler/issues/51>.
       // Performance of this pattern is likely to be bad.
-      name = js.string('constructor', "'");
+      name = _propertyName('constructor');
       // Mark the parameter as no-rename.
       var args = new JS.Identifier('arguments', allowRename: false);
       body = js.statement('''{
         // Get the class name for this instance.
         let name = this.constructor.name;
         // Call the default constructor.
         let init = this[name];
         let result = void 0;
         if (init) result = init.apply(this, #);
         return result === void 0 ? this : result;
       }''', args);
     } else {
       body = _emitConstructorBody(node, fields);
     }
 
     // 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, "'");
+    if (name == null) return _propertyName(className);
     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 72 matching lines @@
   ///   1. field declaration initializer if non-const,
   ///   2. field initializing parameters,
   ///   3. constructor field initializers,
   ///   4. initialize fields not covered in 1-3
   JS.Statement _initializeFields(List<FieldDeclaration> fields,
       [FormalParameterList parameters,
       NodeList<ConstructorInitializer> initializers]) {
     var body = <JS.Statement>[];
 
     // Run field initializers if they can have side-effects.
-    var unsetFields = new Map<String, VariableDeclaration>();
+    var unsetFields = new Map<FieldElement, VariableDeclaration>();
     for (var declaration in fields) {
       for (var field in declaration.fields.variables) {
         if (_isFieldInitConstant(field)) {
-          unsetFields[field.name.name] = field;
+          unsetFields[field.element] = field;
         } else {
           body.add(js.statement(
               '# = #;', [_visit(field.name), _visitInitializer(field)]));
         }
       }
     }
 
     // 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.# = #;', [_emitMemberName(name), _visit(p)]));
-          unsetFields.remove(name);
+          var field = (p.element as FieldFormalParameterElement).field;
+          // Use the getter to initialize the field. This is a bit strange, but
+          // final fields don't have a setter element that we could use instead.
+
+          var memberName =
+              _emitMemberName(field.name, type: field.enclosingElement.type);
+          body.add(js.statement('this.# = #;', [memberName, _visit(p)]));
+          unsetFields.remove(field);
         }
       }
     }
 
     // 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);
+          unsetFields.remove(init.fieldName.staticElement);
         }
       }
     }
 
     // Initialize all remaining fields
-    unsetFields.forEach((name, field) {
+    unsetFields.forEach((field, fieldNode) {
       JS.Expression value;
-      if (field.initializer != null) {
-        value = _visit(field.initializer);
+      if (fieldNode.initializer != null) {
+        value = _visit(fieldNode.initializer);
       } else {
-        var type = rules.elementType(field.element);
+        var type = rules.elementType(field);
+        value = new JS.LiteralNull();
         if (rules.maybeNonNullableType(type)) {
-          value = js.call('dart.as(null, #)', _emitTypeName(type));
-        } else {
-          value = new JS.LiteralNull();
+          value = js.call('dart.as(#, #)', [value, _emitTypeName(type)]);
         }
       }
-      body.add(js.statement('this.# = #;', [_emitMemberName(name), value]));
+      var memberName =
+          _emitMemberName(field.name, type: field.enclosingElement.type);
+      body.add(js.statement('this.# = #;', [memberName, 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();
     }
   }
 
-  JS.Method _emitMethodDeclaration(
-      MethodDeclaration node, Iterable<InterfaceType> extensionTypes) {
+  JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
     if (node.isAbstract || _externalOrNative(node)) {
       return null;
     }
 
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
-    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);
-    }
+    var memberName = _emitMemberName(node.name.name,
+        type: type, unary: params.isEmpty, 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);
 
@@ skipping 64 matching lines @@
   /// Writes a simple identifier. This can handle implicit `this` as well as
   /// going through the qualified library name if necessary.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var e = node.staticElement;
     if (e == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
-    var name = node.name;
     var variable = e is PropertyAccessorElement ? e.variable : e;
+    var name = variable.name;
 
     // 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.#', _emitMemberName(name));
+      return js.call(
+          'this.#', _emitMemberName(name, type: currentClass.element.type));
     }
 
     // static member
     if (e is ExecutableElement &&
         e.isStatic &&
         variable.enclosingElement is ClassElement) {
       var className = (variable.enclosingElement as ClassElement).name;
       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)}');
     }
 
     if (_isTemporary(e)) {
       if (name[0] == '#') {
         return new JS.InterpolatedExpression(name.substring(1));
       } else {
-        return new JSTemporary(e.name);
+        return new JSTemporary(name);
       }
     }
 
     return new JS.Identifier(name);
   }
 
   JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
     return new JS.ArrayInitializer(types.map(_emitTypeName).toList());
   }
 
@@ skipping 49 matching lines @@
       // TODO(jmesserly): remove when we're using coercion reifier.
       return _unimplementedCall('Unimplemented type $type');
     }
 
     var typeArgs = null;
     if (type is ParameterizedType) {
       // TODO(jmesserly): this is a workaround for an analyzer bug, see:
       // https://github.com/dart-lang/dev_compiler/commit/a212d59ad046085a626dd8d16881cdb8e8b9c3fa
       if (type is! FunctionType || element is FunctionTypeAlias) {
         var args = type.typeArguments;
-        if (args.any((a) => a != rules.provider.dynamicType)) {
+        if (args.any((a) => a != types.dynamicType)) {
           name = '$name\$';
           typeArgs = args.map(_emitTypeName);
         }
       }
     }
 
     JS.Expression result;
     if (_needQualifiedName(element)) {
       result = js.call('#.#', [_libraryName(element.library), name]);
     } else {
       result = new JS.Identifier(name);
     }
 
     if (typeArgs != null) {
       result = js.call('#(#)', [result, typeArgs]);
     }
     return result;
   }
 
   bool _needQualifiedName(Element element) {
     var lib = element.library;
     if (lib == null) return false;
     if (lib != currentLibrary) return true;
     if (element is ClassElement) return _lazyClass(element.type);
     if (element is FunctionTypeAliasElement) return _lazyClass(element.type);
     return false;
   }
 
-  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.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
-    return _emitOpAssign(left, right, node.operator.lexeme[0], context: node);
+    return _emitOpAssign(
+        left, right, node.operator.lexeme[0], node.staticElement,
+        context: node);
   }
 
-  JSMetaLet _emitOpAssign(Expression left, Expression right, String op,
+  JSMetaLet _emitOpAssign(
+      Expression left, Expression right, String op, ExecutableElement element,
       {Expression context}) {
     // Desugar `x += y` as `x = x + y`, ensuring that if `x` has subexpressions
     // (for example, x is IndexExpression) we evaluate those once.
     var vars = {};
     var lhs = _bindLeftHandSide(vars, left, context: context);
     var inc = AstBuilder.binaryExpression(lhs, op, right);
-    inc.staticType = rules.getStaticType(left);
+    inc.staticElement = element;
+    inc.staticType = getStaticType(left);
     return new JSMetaLet(vars, [_emitSet(lhs, inc)]);
   }
 
   JS.Expression _emitSet(Expression lhs, Expression rhs) {
     if (lhs is IndexExpression) {
-      String code;
-      var target = _getTarget(lhs);
-      if (rules.isDynamicTarget(target)) {
-        code = 'dart.dsetindex(#, #, #)';
-        return js.call(code, [_visit(target), _visit(lhs.index), _visit(rhs)]);
-      }
-      return js.call('#.#(#, #)', [
+      return _emitSend(_getTarget(lhs), '[]=', [lhs.index, rhs]);
+    }
+
+    Expression target = null;
+    SimpleIdentifier id;
+    if (lhs is PropertyAccess) {
+      target = _getTarget(lhs);
+      id = lhs.propertyName;
+    } else if (lhs is PrefixedIdentifier) {
+      target = lhs.prefix;
+      id = lhs.identifier;
+    }
+
+    if (target != null && rules.isDynamicTarget(target)) {
+      return js.call('dart.$DPUT(#, #, #)', [
         _visit(target),
-        _emitMemberName('[]=', target: target),
-        _visit(lhs.index),
+        _emitMemberName(id.name, type: getStaticType(target)),
         _visit(rhs)
       ]);
     }
 
-    if (lhs is PropertyAccess) {
-      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 = _emitDSetIfDynamic(lhs.prefix, lhs.identifier, rhs);
-      if (result != null) return result;
-    }
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
   @override
   JS.Block visitExpressionFunctionBody(ExpressionFunctionBody node) {
     var initArgs = _emitArgumentInitializers(_parametersOf(node.parent));
     var ret = new JS.Return(_visit(node.expression));
     return new JS.Block(initArgs != null ? [initArgs, ret] : [ret]);
   }
 
@@ skipping 11 matching lines @@
   @override
   JS.Block visitBlock(Block node) => new JS.Block(_visitList(node.statements));
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.isCascaded ? _cascadeTarget : node.target;
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
-    if (rules.isDynamicCall(node.methodName)) {
-      var args = _visit(node.argumentList);
-      if (target != null) {
-        return js.call('dart.dsend(#, #, #)', [
-          _visit(target),
-          js.string(node.methodName.name, "'"),
-          args
-        ]);
+    // TODO(jmesserly): if we try to call a getter returning a function with
+    // a call method, we don't generate the `.call` correctly.
+    String code;
+    if (target == null) {
+      if (rules.isDynamicCall(node.methodName)) {
+        code = 'dart.$DCALL(#, #)';
       } else {
-        return js.call('dart.dcall(#, #)', [_visit(node.methodName), args]);
+        code = '#(#)';
       }
+      return js.call(
+          code, [_visit(node.methodName), _visit(node.argumentList)]);
     }
 
-    // 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),
-        _emitMemberName(node.methodName.name, target: target)
-      ]);
+    // TODO(jmesserly): if the methodName resolves statically but the call is
+    // dynamic (e.g. `obj.method` is resolved to a field of type `Function`), we
+    // could generate call(#.#, #). Not sure if that's worth it.
+    if (rules.isDynamicCall(node.methodName)) {
+      code = 'dart.$DSEND(#, #, #)';
     } else {
-      targetJs = _visit(node.methodName);
+      code = '#.#(#)';
     }
-
-    return js.call('#(#)', [targetJs, _visit(node.argumentList)]);
+    return js.call(code, [
+      _visit(target),
+      _emitMemberName(node.methodName.name, type: getStaticType(target)),
+      _visit(node.argumentList)
+    ]);
   }
 
   /// Emits code for the `JS(...)` builtin.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
     if (e is FunctionElement &&
         e.library.name == '_foreign_helper' &&
         e.name == 'JS') {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
       var code = args[1] as StringLiteral;
 
       var template = js.parseForeignJS(code.stringValue);
       var result = template.instantiate(_visitList(args.skip(2)));
       // `throw` is emitted as a statement by `parseForeignJS`.
       assert(result is JS.Expression || node.parent is ExpressionStatement);
       return result;
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     var code;
     if (rules.isDynamicCall(node.function)) {
-      code = 'dart.dcall(#, #)';
+      code = 'dart.$DCALL(#, #)';
     } else {
       code = '#(#)';
     }
     return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
   }
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
@@ skipping 145 matching lines @@
       _exportsVar,
       _properties.map(_emitTopLevelProperty)
     ]));
     _properties.clear();
   }
 
   @override
   visitConstructorName(ConstructorName node) {
     var typeName = _visit(node.type);
     if (node.name != null) {
-      return js.call(
-          '#.#', [typeName, _emitMemberName(node.name.name, isStatic: true)]);
+      return js.call('#.#', [typeName, _emitMemberName(node.name.name)]);
     }
     return typeName;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     return js.call(
         'new #(#)', [_visit(node.constructorName), _visit(node.argumentList)]);
   }
 
@@ skipping 13 matching lines @@
   bool typeIsNonNullablePrimitiveInJS(DartType t) =>
       typeIsPrimitiveInJS(t) && rules.isNonNullableType(t);
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   bool _isNonNullableExpression(Expression expr) {
     // If the type is non-nullable, no further checking needed.
-    if (rules.isNonNullableType(rules.getStaticType(expr))) return true;
+    if (rules.isNonNullableType(getStaticType(expr))) return true;
 
     // TODO(vsm): Revisit whether we really need this when we get
     // better non-nullability in the type system.
 
-    if (expr is Literal && expr is! NullLiteral) {
-      return true;
-    }
+    if (expr is Literal && expr is! NullLiteral) return true;
+    if (expr is IsExpression) return true;
     if (expr is ParenthesizedExpression) {
       return _isNonNullableExpression(expr.expression);
     }
     if (expr is Conversion) {
       return _isNonNullableExpression(expr.expression);
     }
     DartType type = null;
     if (expr is BinaryExpression) {
-      type = rules.getStaticType(expr.leftOperand);
+      type = getStaticType(expr.leftOperand);
     } else if (expr is PrefixExpression) {
-      type = rules.getStaticType(expr.operand);
+      type = getStaticType(expr.operand);
     } else if (expr is PostfixExpression) {
-      type = rules.getStaticType(expr.operand);
+      type = getStaticType(expr.operand);
     }
     if (type != null && typeIsPrimitiveInJS(type)) {
       return true;
     }
     if (expr is MethodInvocation) {
       // TODO(vsm): This logic overlaps with the resolver.
       // Where is the best place to put this?
       var e = expr.methodName.staticElement;
       if (e is FunctionElement &&
           e.library.name == '_foreign_helper' &&
@@ skipping 23 matching lines @@
     } else {
       return js.call('dart.notNull(#)', _visit(expr));
     }
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
-    var leftType = rules.getStaticType(left);
-    var rightType = rules.getStaticType(right);
+    var leftType = getStaticType(left);
+    var rightType = getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if both sides are the same primitive type.
       if (_canUsePrimitiveEquality(left, right)) {
         code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
       return js.call(code, [_visit(left), _visit(right)]);
-    } else if (binaryOperationIsPrimitive(leftType, rightType)) {
+    }
+
+    if (binaryOperationIsPrimitive(leftType, rightType)) {
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         code = '(# / #).truncate()';
       } else {
         // TODO(vsm): When do Dart ops not map to JS?
         code = '# $op #';
       }
       return js.call(code, [notNull(left), notNull(right)]);
-    } else {
-      var opString = js.string(op.lexeme, "'");
-      if (rules.isDynamicTarget(left)) {
-        // dynamic dispatch
-        return js.call(
-            'dart.dsend(#, #, #)', [_visit(left), opString, _visit(right)]);
-      } else if (_isJSBuiltinType(leftType)) {
-        // TODO(jmesserly): we'd get better readability from the static-dispatch
-        // pattern below. Consider:
-        //
-        //     "hello"['+']"world"
-        // vs
-        //     core.String['+']("hello", "world")
-        //
-        // Infix notation is much more readable, which is a bit part of why
-        // C# added its extension methods feature. However this would require
-        // adding these methods to String.prototype/Number.prototype in JS.
-        return js.call('#.#(#, #)', [
-          _emitTypeName(leftType),
-          opString,
-          _visit(left),
-          _visit(right)
-        ]);
-      } else {
-        // Generic static-dispatch, user-defined operator code path.
-        return js.call('#.#(#)', [_visit(left), opString, _visit(right)]);
-      }
     }
+
+    return _emitSend(left, op.lexeme, [right]);
   }
 
   /// If the type [t] is [int] or [double], returns [num].
   /// Otherwise returns [t].
   DartType _canonicalizeNumTypes(DartType t) {
-    var numType = rules.provider.numType;
+    var numType = types.numType;
     if (t is InterfaceType && t.superclass == numType) return numType;
     return t;
   }
 
   bool _canUsePrimitiveEquality(Expression left, Expression right) {
     if (_isNull(left) || _isNull(right)) return true;
 
-    var leftType = _canonicalizeNumTypes(rules.getStaticType(left));
-    var rightType = _canonicalizeNumTypes(rules.getStaticType(right));
+    var leftType = _canonicalizeNumTypes(getStaticType(left));
+    var rightType = _canonicalizeNumTypes(getStaticType(right));
     return _isJSBuiltinType(leftType) && leftType == rightType;
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
   SimpleIdentifier _createTemporary(String name, DartType type) {
     // We use an invalid source location to signal that this is a temporary.
     // See [_isTemporary].
     // TODO(jmesserly): alternatives are
     // * (ab)use Element.isSynthetic, which isn't currently used for
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
     id.staticElement = new LocalVariableElementImpl.forNode(id);
     id.staticType = type;
     return id;
   }
 
   bool _isTemporary(Element node) => node.nameOffset == -1;
 
-  /// Desugars postfix increment.
-  ///
-  /// In the general case [expr] can be one of [IndexExpression],
-  /// [PrefixExpression] or [PropertyAccess] and we need to
-  /// ensure sub-expressions are evaluated once.
-  ///
-  /// We also need to ensure we can return the original value of the expression,
-  /// and that it is only evaluated once.
-  ///
-  /// We desugar this using let*.
-  ///
-  /// For example, `expr1[expr2]++` can be transformed to this:
-  ///
-  ///     // psuedocode mix of Scheme and JS:
-  ///     (let* (x1=expr1, x2=expr2, t=expr1[expr2]) { x1[x2] = t + 1; t })
-  ///
-  /// The [JSMetaLet] nodes automatically simplify themselves if they can.
-  /// For example, if the result value is not used, then `t` goes away.
-  JSMetaLet _emitPostfixIncrement(Expression expr, Token op) {
-    var type = rules.getStaticType(expr);
-    assert(type != null);
-
-    // Handle the left hand side, to ensure each of its subexpressions are
-    // evaluated only once.
-    var vars = {};
-    var left = _bindLeftHandSide(vars, expr, context: expr);
-
-    // Desugar `x++` as `(x1 = x0 + 1, x0)` where `x0` is the original value
-    // and `x1` is the new value for `x`.
-    var x = _bindValue(vars, 'x', left, context: expr);
-
-    var one = AstBuilder.integerLiteral(1);
-    one.staticType = rules.provider.intType;
-    var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one);
-    increment.staticType = type;
-
-    var body = [_emitSet(left, increment), _visit(x)];
-    return new JSMetaLet(vars, body, statelessResult: true);
-  }
-
   /// Returns a new expression, which can be be used safely *once* on the
   /// left hand side, and *once* on the right side of an assignment.
   /// For example: `expr1[expr2] += y` can be compiled as
   /// `expr1[expr2] = expr1[expr2] + y`.
   ///
   /// The temporary scope will ensure `expr1` and `expr2` are only evaluated
   /// once: `((x1, x2) => x1[x2] = x1[x2] + y)(expr1, expr2)`.
   ///
   /// If the expression does not end up using `x1` or `x2` more than once, or
   /// if those expressions can be treated as stateless (e.g. they are
@@ skipping 40 matching lines @@
       Map<String, JS.Expression> scope, String name, Expression expr,
       {Expression context}) {
     // No need to do anything for stateless expressions.
     if (_isStateless(expr, context)) return expr;
 
     var t = _createTemporary('#$name', expr.staticType);
     scope[name] = _visit(expr);
     return t;
   }
 
+  /// Desugars postfix increment.
+  ///
+  /// In the general case [expr] can be one of [IndexExpression],
+  /// [PrefixExpression] or [PropertyAccess] and we need to
+  /// ensure sub-expressions are evaluated once.
+  ///
+  /// We also need to ensure we can return the original value of the expression,
+  /// and that it is only evaluated once.
+  ///
+  /// We desugar this using let*.
+  ///
+  /// For example, `expr1[expr2]++` can be transformed to this:
+  ///
+  ///     // psuedocode mix of Scheme and JS:
+  ///     (let* (x1=expr1, x2=expr2, t=expr1[expr2]) { x1[x2] = t + 1; t })
+  ///
+  /// The [JSMetaLet] nodes automatically simplify themselves if they can.
+  /// For example, if the result value is not used, then `t` goes away.
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
-    var dispatchType = rules.getStaticType(expr);
+    var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       if (_isNonNullableExpression(expr)) {
         return js.call('#$op', _visit(expr));
       }
     }
 
     assert(op.lexeme == '++' || op.lexeme == '--');
-    return _emitPostfixIncrement(expr, op);
+
+    // Handle the left hand side, to ensure each of its subexpressions are
+    // evaluated only once.
+    var vars = {};
+    var left = _bindLeftHandSide(vars, expr, context: expr);
+
+    // Desugar `x++` as `(x1 = x0 + 1, x0)` where `x0` is the original value
+    // and `x1` is the new value for `x`.
+    var x = _bindValue(vars, 'x', left, context: expr);
+
+    var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
+    var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one)
+      ..staticElement = node.staticElement
+      ..staticType = getStaticType(expr);
+
+    var body = [_emitSet(left, increment), _visit(x)];
+    return new JSMetaLet(vars, body, statelessResult: true);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
-    return _emitPrefixExpression(node.operator, node.operand);
-  }
+    var op = node.operator;
+    var expr = node.operand;
 
-  JS.Expression _emitPrefixExpression(Token op, Expression expr) {
-    var dispatchType = rules.getStaticType(expr);
+    var dispatchType = 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];
         var vars = {};
         var x = _bindLeftHandSide(vars, expr, context: expr);
         var body = js.call('# = # $mathop 1', [_visit(x), notNull(x)]);
         return new JSMetaLet(vars, [body]);
       } else {
         return js.call('$op#', notNull(expr));
       }
     }
 
     if (op.lexeme == '++' || op.lexeme == '--') {
       // Increment or decrement requires expansion.
       // Desugar `++x` as `x = x + 1`, ensuring that if `x` has subexpressions
       // (for example, x is IndexExpression) we evaluate those once.
-      var one = AstBuilder.integerLiteral(1)
-        ..staticType = rules.provider.intType;
-      return _emitOpAssign(expr, one, op.lexeme[0], context: expr);
+      var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
+      return _emitOpAssign(expr, one, op.lexeme[0], node.staticElement,
+          context: expr);
     }
 
-    // Call the operator
-    var opString = _emitMemberName(op.lexeme, unary: true);
-    if (rules.isDynamicTarget(expr)) {
-      // dynamic dispatch
-      return js.call('dart.dsend(#, #)', [_visit(expr), opString]);
-    } 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]);
-    }
+    return _emitSend(expr, op.lexeme[0], []);
   }
 
   // Cascades can contain [IndexExpression], [MethodInvocation] and
   // [PropertyAccess]. The code generation for those is handled in their
   // respective visit methods.
   @override
   JS.Node visitCascadeExpression(CascadeExpression node) {
     var savedCascadeTemp = _cascadeTarget;
 
     var vars = {};
@@ skipping 18 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 _emitGet(node.prefix, node.identifier);
+      return _emitGet(node.prefix, node.identifier.name);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
-      _emitGet(_getTarget(node), node.propertyName);
+      _emitGet(_getTarget(node), node.propertyName.name);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
-  _emitGet(Expression target, SimpleIdentifier name) {
+  JS.Expression _emitGet(Expression target, String memberName) {
+    var name = _emitMemberName(memberName, type: getStaticType(target));
     if (rules.isDynamicTarget(target)) {
-      return js.call(
-          'dart.dload(#, #)', [_visit(target), js.string(name.name, "'")]);
+      return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
     } else {
-      var e = name.staticElement;
-      var ret = js.call('#.#', [
+      return js.call('#.#', [_visit(target), name]);
+    }
+  }
+
+  JS.Expression _emitSend(
+      Expression target, String name, List<Expression> args) {
+    var type = getStaticType(target);
+    var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
+    if (rules.isDynamicTarget(target)) {
+      // dynamic dispatch
+      var dynamicHelper = const {'[]': DINDEX, '[]=': DSETINDEX}[name];
+      if (dynamicHelper != null) {
+        return js.call(
+            'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
+      }
+      return js.call('dart.$DSEND(#, #, #)', [
         _visit(target),
-        _emitMemberName(name.name,
-            isStatic: e is ExecutableElement && e.isStatic, target: target)
+        memberName,
+        _visitList(args)
       ]);
-      return ret;
     }
+    if (_isJSBuiltinType(type)) {
+      // static call pattern for bultins.
+      return js.call('#.#(#, #)', [
+        _emitTypeName(type),
+        memberName,
+        _visit(target),
+        _visitList(args)
+      ]);
+    }
+    // Generic dispatch to a statically known method.
+    return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
-    var target = _getTarget(node);
-    if (rules.isDynamicTarget(target)) {
-      return js.call('dart.dindex(#, #)', [_visit(target), _visit(node.index)]);
-    }
-
-    return js.call('#.#(#)', [
-      _visit(target),
-      _emitMemberName('[]', target: target),
-      _visit(node.index)
-    ]);
+    return _emitSend(_getTarget(node), '[]', [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 81 matching lines @@
     if (clauses == null || clauses.isEmpty) return null;
 
     // TODO(jmesserly): need a better way to get a temporary variable.
     // This could incorrectly shadow a user's name.
     var savedCatch = _catchParameter;
 
     if (clauses.length == 1 && clauses.single.exceptionParameter != null) {
       // Special case for a single catch.
       _catchParameter = clauses.single.exceptionParameter;
     } else {
-      _catchParameter = _createTemporary('e', rules.provider.dynamicType);
+      _catchParameter = _createTemporary('e', types.dynamicType);
     }
 
     JS.Statement catchBody = js.statement('throw #;', _visit(_catchParameter));
     for (var clause in clauses.reversed) {
       catchBody = _catchClauseGuard(clause, catchBody);
     }
 
     var catchVarDecl = _visit(_catchParameter);
     _catchParameter = savedCatch;
     return new JS.Catch(catchVarDecl, new JS.Block([catchBody]));
@@ skipping 255 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,
-      {bool unary: false, bool isStatic: false, Expression target}) {
-    if (isStatic == false && target != null) {
-      var ret = nameIfExtension(target, name);
-      if (ret != null) return ret;
-    }
+      {DartType type, bool unary: false, bool isStatic: false}) {
     if (name.startsWith('_')) {
       if (_privateNames.add(name)) _pendingPrivateNames.add(name);
       return new JSTemporary(name);
     }
-    return _propertyName(_jsMemberName(name, unary: unary, isStatic: isStatic));
-  }
+    // Check for extension method:
+    var extLibrary = _findExtensionLibrary(name, type);
 
-  String _jsMemberName(String name, {bool unary: false, bool isStatic: false}) {
-    if (name == '[]') return 'get';
-    if (name == '[]=') return 'set';
-    if (unary && name == '-') return 'unary-';
+    if (name == '[]') {
+      name = 'get';
+    } else if (name == '[]=') {
+      name = 'set';
+    } else if (name == '-' && unary) {
+      name = '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.
-      return '$name*';
+      name = '$name*';
     }
-    return name;
+
+    if (extLibrary != null) {
+      return js.call('#.#', [
+        _libraryName(extLibrary),
+        _propertyName(_addExtensionMethodName(name, extLibrary))
+      ]);
+    }
+
+    return _propertyName(name);
   }
 
-  JS.LiteralString _emitExtensionMethodName(String name) =>
-      js.string(_extensionMethodName(name), "'");
+  LibraryElement _findExtensionLibrary(String name, DartType type) {
+    if (type is! InterfaceType) return null;
 
-  String _extensionMethodName(String name) => '\$${_jsMemberName(name)}';
+    var extLibrary = null;
+    var extensionTypes = _extensionMethods[name];
+    if (extensionTypes != null) {
+      // Normalize the type to ignore generics.
+      type = fillDynamicTypeArgs(type, types);
+      for (var t in extensionTypes) {
+        if (rules.isSubTypeOf(type, t)) {
+          assert(extLibrary == null || extLibrary == t.element.library);
+          extLibrary = t.element.library;
+        }
+      }
+    }
+    return extLibrary;
+  }
+
+  String _addExtensionMethodName(String name, LibraryElement extLibrary) {
+    var extensionMethodName = '\$$name';
+    if (extLibrary == 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(extensionMethodName)) {
+        _pendingExtensionMethodNames.add(extensionMethodName);
+        _addExport(extensionMethodName);
+      }
+    }
+    return extensionMethodName;
+  }
 
   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) {
     if (library == libraryInfo.library) return _exportsVar;
     return new JS.Identifier(jsLibraryName(library));
   }
 
+  DartType getStaticType(Expression e) => rules.getStaticType(e);
+
   static bool _needsImplicitThis(Element e) =>
       e is PropertyAccessorElement && !e.variable.isStatic ||
           e is ClassMemberElement && !e.isStatic && e is! ConstructorElement;
+
+  static const DPUT = 'dput';

[Jacob, 2015/04/14 21:41:06]

nit: no idea if dart has an official convention but generally I like constants
at the top of the file with a comment specifying what they are. Could be just a
single // comment for all 6 of these.

[Jennifer Messerly, 2015/04/14 22:17:19]

Hmm. I guess I absorbed a rule at some point from someone to put
implementation-y details near the end, out of the main flow for the reader. I'm
fine moving them, but did you mean top of class or top of file? If top of class,
does it go before instance fields/ctors? Right now they're scoped to the class,
since I didn't think it made sense to use outside of the class scope.

(side note: technically the camelCase convention is preferred too, but it'd
probably be bad here, as we need to ensure the argument to js.call() and
js.statement() is always a const string.)

[Jacob, 2015/04/14 22:25:00]

I don't care deeply about it but I'd personally make these top level to the
library instead of static as that semantically makes sense to me as  the impact
is global given how these constants change the generated code. Perhaps keeping
them at the top is cargo cult wisdom from the days of C where that would
actually matter in terms of how they were resolved..

FWIW the dart style guide examples do show top level consts before the class not
after it.
const pi = 3.14;
const defaultTimeout = 1000;
final urlScheme = new RegExp('^([a-z]+):');

class Dice {
  static final numberGenerator = new Random();
}

[Jennifer Messerly, 2015/04/14 22:45:28]

OK. Moved to top, added comment.

+  static const DLOAD = 'dload';
+  static const DINDEX = 'dindex';
+  static const DSETINDEX = 'dsetindex';
+  static const DCALL = 'dcall';
+  static const DSEND = 'dsend';
 }
 
 class JSGenerator extends CodeGenerator {
   final JSCodeOptions options;
 
+  /// For fast lookup of extension methods, we first check the name, then do a
+  /// (possibly expensive) subtype test to see if it matches one of the types
+  /// that declares that method.
+  final _extensionMethods = new HashMap<String, List<InterfaceType>>();
+
   JSGenerator(String outDir, Uri root, TypeRules rules, this.options)
-      : super(outDir, root, rules);
+      : super(outDir, root, rules) {
+
+    // 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.
+    var extensionTypes = [types.listType, types.iterableType];
+    for (var type in extensionTypes) {
+      type = fillDynamicTypeArgs(type, rules.provider);
+      var e = type.element;
+      var names = new HashSet<String>()
+        ..addAll(e.methods.map((m) => m.name))
+        ..addAll(e.accessors.map((m) => m.name));
+      for (var name in names) {
+        _extensionMethods.putIfAbsent(name, () => []).add(type);
+      }
+    }
+  }
+
+  TypeProvider get types => rules.provider;
 
   String generateLibrary(LibraryUnit unit, LibraryInfo info) {
-    var jsTree = new JSCodegenVisitor(info, rules).emitLibrary(unit);
+    var jsTree =
+        new JSCodegenVisitor(info, rules, _extensionMethods).emitLibrary(unit);
 
     var outputPath = path.join(outDir, jsOutputPath(info, root));
     new Directory(path.dirname(outputPath)).createSync(recursive: true);
 
     if (options.emitSourceMaps) {
       var outFilename = path.basename(outputPath);
       var printer = new srcmaps.Printer(outFilename);
       _writeNode(
           new SourceMapPrintingContext(printer, path.dirname(outputPath)),
           jsTree);
@@ skipping 209 matching lines @@
     if (args.isNotEmpty && args[0] is NamedExpression) {
       NamedExpression named = args[0];
       if (named.name.label.name == argName &&
           named.expression is StringLiteral) {
         return (named.expression as StringLiteral).stringValue;
       }
     }
   }
   return null;
 }