implement tear offs

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 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1011 matching lines @@
         (element.library != libraryInfo.library ||
             element is TopLevelVariableElement && !element.isConst)) {
       return js.call('#.#', [_libraryName(element.library), name]);
     }
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
+      var member = _emitMemberName(name, isStatic: isStatic, type: type);
 
-      // For instance methods, we add implicit-this.
       // For static methods, we add the raw type name, without generics or
       // library prefix. We don't need those because static calls can't use
       // the generic type.
-      var target = isStatic ? new JS.Identifier(type.name) : new JS.This();
-      var member = _emitMemberName(name, isStatic: isStatic, type: type);
-      return new JS.PropertyAccess(target, member);
+      if (isStatic) {
+        return js.call('#.#', [type.name, member]);
+      }
+
+      // For instance members, we add implicit-this.
+      // For method tear-offs, we ensure it's a bound method.
+      var code = 'this.#';
+      if (element is MethodElement && !inInvocationContext(node)) {
+        code += '.bind(this)';
+      }
+      return js.call(code, member);
     }
 
     // initializing formal parameter, e.g. `Point(this.x)`
     if (element is ParameterElement &&
         element.isInitializingFormal &&
         element.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 _getTemp(element, '${name.substring(1)}');
@@ skipping 171 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;
 
-    // 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 || isLibraryPrefix(target)) {
       if (rules.isDynamicCall(node.methodName)) {
         code = 'dart.$DCALL(#, #)';
       } else {
         code = '#(#)';
       }
       return js.call(
           code, [_visit(node.methodName), _visit(node.argumentList)]);
     }
 
-    // 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)) {
+    if (rules.isDynamicTarget(target)) {
       code = 'dart.$DSEND(#, #, #)';
+    } else if (rules.isDynamicCall(node.methodName)) {
+      // This is a dynamic call to a statically know target. For example:
+      //     class Foo { Function bar; }
+      //     new Foo().bar(); // dynamic call
+      code = 'dart.$DCALL(#.#, #)';
     } else {
       code = '#.#(#)';
     }
     return js.call(code, [
       _visit(target),
       _emitMemberName(node.methodName.name, type: getStaticType(target)),
       _visit(node.argumentList)
     ]);
   }
 
@@ skipping 530 matching lines @@
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (isLibraryPrefix(node.prefix)) {
       return _visit(node.identifier);
     } else {
-      return _emitGet(node.prefix, node.identifier.name);
+      return _emitGet(node.prefix, node.identifier);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) =>
-      _emitGet(_getTarget(node), node.propertyName.name);
+      _emitGet(_getTarget(node), node.propertyName);
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
-  JS.Expression _emitGet(Expression target, String memberName) {
-    var name = _emitMemberName(memberName, type: getStaticType(target));
+  JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
+    var name = _emitMemberName(memberId.name, type: getStaticType(target));
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
+    }
+
+    String code;
+    var member = memberId.staticElement;
+    if (member != null && member is MethodElement) {
+      // Tear-off methods: explicitly bind it.
+      if (isStateless(target, target)) {
+        return js.call('#.#.bind(#)', [_visit(target), name, _visit(target)]);
+      }
+      code = 'dart.bind(#, #)';
     } else {
-      return js.call('#.#', [_visit(target), name]);
+      code = '#.#';
     }
+
+    return js.call(code, [_visit(target), name]);
   }
 
+  /// Emits a generic send, like an operator method.
+  ///
+  /// **Please note** this function does not support method invocation syntax
+  /// `obj.name(args)` because that could be a getter followed by a call.
+  /// See [visitMethodInvocation].
   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),
         memberName,
         _visitList(args)
       ]);
     }
+
     if (_isJSBuiltinType(type)) {
-      // static call pattern for bultins.
+      // static call pattern for builtins.
       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)]);
   }
@@ skipping 538 matching lines @@
   return filepath;
 }
 
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == '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;