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 16 matching lines @@
         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;
 
+// Various dynamic helpers we call.
+// If renaming these, make sure to check other places like the
+// dart_runtime.js file and comments.
+// TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
+// import and generate calls to, rather than dart_runtime.js
+const DPUT = 'dput';
+const DLOAD = 'dload';
+const DINDEX = 'dindex';
+const DSETINDEX = 'dsetindex';
+const DCALL = 'dcall';
+const DSEND = 'dsend';
+
 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;
 }
 
 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;
 }