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 1096 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.tearoff(this, #)' : 'this.#';

[Jennifer Messerly, 2015/05/20 16:05:17]

I don't think we should call this "tearoff" in generated code. Inside the Dart
team we've used this name in discussions, but it's not a broader term. I chose
"bind" because that's the name JavaScript uses for this concept, and a search
for "javascript bind" or "function bind" finds the right concept.

[Leaf, 2015/05/20 16:35:17]

So you're saying change dart.bind to both bind the function and add rtti and
then just use that?  That's fine by me.  

[Jennifer Messerly, 2015/05/20 16:50:30]

err, I think so :). What do we still use "dart.bind" for after your CL?

[Leaf, 2015/05/20 17:05:56]

Apparently nothing.  Made the switch.

       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 851 matching lines @@
   JS.Expression _emitGet(Expression target, SimpleIdentifier memberId) {
     var member = memberId.staticElement;
     bool isStatic = member is ExecutableElement && member.isStatic;
     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)]);

[Jennifer Messerly, 2015/05/20 16:05:17]

this makes me a little sad, as we never generate "normal" JavaScript code
anymore. I guess we can bring it back with the --no-rtti compiler option, at
some point in the future?

[Leaf, 2015/05/20 16:35:17]

Hmm.  I actually kind of felt like it was often an improvement in the generated
code - maybe it's a tradeoff between being idiomatic and being brief?  Can bind
be overridden?  If so then maybe I could work it out so that the original
pattern worked.

[Jennifer Messerly, 2015/05/20 16:50:30]

yeah, exactly ... in JS it's not something you'd typically call a helper for,
because it's so easy to `.bind(this)`. Then again, if we could turn our
dart_runtime.js more into a general "ES6 with types" library, I think that would
make me feel better about having those runtime helpers and using them so much.

But yeah, no worries, this particular one isn't a big deal in the grand scheme.
My concerns are a bit higher level. Maybe we'll get time at some point for a
coherent readability/design review of the JS we're generating.
Kind of. We could alter "Function.prototype.bind". But probably not worth just
for this.

-      }
-      code = 'dart.bind(#, #)';
+      code = 'dart.tearoff(#, #)';
     } else if (_requiresStaticDispatch(target, memberId.name)) {
       return js.call('dart.#(#)', [name, _visit(target)]);
     } else {
       code = '#.#';
     }
 
     return js.call(code, [_visit(target), name]);
   }
 
   /// Emits a generic send, like an operator method.
@@ skipping 555 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);
 }