move => bind this workaround to js_ast

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;
@@ skipping 895 matching lines @@
   }
 
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     if (node.parent is FunctionDeclaration) {
       return new JS.Fun(params, _visit(node.body));
     } else {
-      var bindThis = _maybeBindThis(node.body);
-
       String code;
       AstNode body;
       var nodeBody = node.body;
       if (nodeBody is ExpressionFunctionBody) {
         code = '(#) => #';
         body = nodeBody.expression;
       } else {
         code = '(#) => { #; }';
         body = nodeBody;
       }
-      return js.call('($code)$bindThis', [params, _visit(body)]);
+      return js.call(code, [params, _visit(body)]);
     }
   }
 
   @override
   JS.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var func = node.functionDeclaration;
     if (func.isGetter || func.isSetter) {
       return js.comment('Unimplemented function get/set statement: $node');
     }
@@ skipping 585 matching lines @@
   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));
     return _isJSBuiltinType(leftType) && leftType == rightType;
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
-  // TODO(jmesserly, vsm): Refactor this logic.
   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;
 
   JS.Expression _emitPostfixIncrement(Expression expr, Token op) {
     var type = rules.getStaticType(expr);
     assert(type != null);
     var tmp = _createTemporary('x', type);
 
     // Increment and write
     var one = AstBuilder.integerLiteral(1);
     one.staticType = rules.provider.intType;
     var increment = AstBuilder.binaryExpression(tmp, op.lexeme[0], one);
     increment.staticType = type;
     var write = _emitAssignment(expr, increment);
 
-    var bindThis = _maybeBindThis(expr);
-    return js.call("((#) => (#, #))$bindThis(#)", [
-      _visit(tmp),
-      write,
-      _visit(tmp),
-      _visit(expr)
-    ]);
+    return js.call(
+        "((#) => (#, #))(#)", [_visit(tmp), write, _visit(tmp), _visit(expr)]);
   }
 
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     if (node.parent is Statement) {
       // Prefix code is simpler.  If the expr result isn't used, fall to that.
       return _emitPrefixExpression(op, expr);
@@ skipping 74 matching lines @@
       } else {
         // Use comma expression. For example:
         //    (sb.write(1), sb.write(2), sb)
         var sections = _visitListToBinary(node.cascadeSections, ',');
         result = new JS.Binary(',', sections, _visit(_cascadeTarget));
       }
     } else {
       // In the general case we need to capture the target expression into
       // a temporary. This uses a lambda to get a temporary scope, and it also
       // remains valid in an expression context.
-      // TODO(jmesserly): need a better way to handle temps.
-      // TODO(jmesserly): special case for parent is ExpressionStatement?
       _cascadeTarget = _createTemporary('_', node.target.staticType);
 
       var body = _visitList(node.cascadeSections);
       if (node.parent is! ExpressionStatement) {
         body.add(js.statement('return #;', _visit(_cascadeTarget)));
       }
 
-      var bindThis = _maybeBindThis(node.cascadeSections);
-      result = js.call('((#) => { # })$bindThis(#)', [
+      result = js.call('((#) => { # })(#)', [
         _visit(_cascadeTarget),
         body,
         _visit(node.target)
       ]);
     }
 
     _cascadeTarget = savedCascadeTemp;
     return result;
   }
 
@@ skipping 484 matching lines @@
       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));
   }
 
-  String _maybeBindThis(node) {
-    if (currentClass == null) return '';
-    var visitor = _BindThisVisitor._instance;
-    visitor._bindThis = false;
-    node.accept(visitor);
-    return visitor._bindThis ? '.bind(this)' : '';
-  }
-
   static bool _needsImplicitThis(Element e) =>
       e is PropertyAccessorElement && !e.variable.isStatic ||
           e is ClassMemberElement && !e.isStatic && e is! ConstructorElement;
 }
 
 /// Returns true if the local variable is potentially mutated within [context].
 /// This accounts for closures that may have been created outside of [context].
 bool _isPotentiallyMutated(VariableElementImpl e, [AstNode context]) {
   if (e.isPotentiallyMutatedInClosure) {
     // TODO(jmesserly): this returns true incorrectly in some cases, because
@@ skipping 34 matching lines @@
         identical(parent.methodName, node)) return;
     if (parent is ConstructorName) return;
     if (parent is Label) return;
 
     if (node.inSetterContext() && node.staticElement == _variable) {
       _potentiallyMutated = true;
     }
   }
 }
 
-/// This is a workaround for V8 arrow function bindings being not yet
-/// implemented. See issue #43
-// TODO(jmesserly): cleaner to handle this workaround on the JS side.
-class _BindThisVisitor extends RecursiveAstVisitor {
-  static _BindThisVisitor _instance = new _BindThisVisitor();
-  bool _bindThis = false;
-
-  @override
-  visitSimpleIdentifier(SimpleIdentifier node) {
-    if (JSCodegenVisitor._needsImplicitThis(node.staticElement)) {
-      _bindThis = true;
-    }
-  }
-
-  @override
-  visitThisExpression(ThisExpression node) {
-    _bindThis = true;
-  }
-}
-
 class JSGenerator extends CodeGenerator {
   final JSCodeOptions options;
 
   JSGenerator(String outDir, Uri root, TypeRules rules, this.options)
       : super(outDir, root, rules);
 
   String generateLibrary(
       LibraryUnit unit, LibraryInfo info, CheckerReporter reporter) {
     var jsTree = new JSCodegenVisitor(info, rules, reporter).emitLibrary(unit);
 
@@ skipping 112 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }