Use dart.tearoff helper at tearoff sites

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 1106 matching lines @@
       // 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.
       if (isStatic) {
         var dynType = _emitTypeName(fillDynamicTypeArgs(type, types));
         return new JS.PropertyAccess(dynType, 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)';
-      }
+      var tearOff = element is MethodElement && !inInvocationContext(node);
+      var code = (tearOff) ? 'dart.bind(this, #)' : '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.
@@ skipping 855 matching lines @@
     if (isStatic) {
       _loader.declareBeforeUse(member);
     }
     var name = _emitMemberName(memberId.name,
         type: getStaticType(target), isStatic: isStatic);
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.$DLOAD(#, #)', [_visit(target), name]);
     }
 
     String code;
-    if (member != null && member is MethodElement) {
+    if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
+      // TODO(leafp): Attach runtime types to these static tearoffs
       if (_requiresStaticDispatch(target, memberId.name)) {
         return js.call('dart.#.bind(#)', [name, _visit(target)]);
       }
-      if (isStateless(target, target)) {
-        return js.call('#.#.bind(#)', [_visit(target), name, _visit(target)]);
-      }
       code = 'dart.bind(#, #)';
     } else if (_requiresStaticDispatch(target, memberId.name)) {
       return js.call('dart.#(#)', [name, _visit(target)]);
     } else {
       code = '#.#';
     }
 
     return js.call(code, [_visit(target), name]);
   }
 
@@ skipping 556 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }