Make sure to bind a method to its receiver if it is stored in a temporary.

pkg/compiler/lib/src/js/rewrite_async.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 rewrite_async;
 
 import "dart:math" show max;
 import 'dart:collection';
 
 import 'package:_internal/compiler/js_lib/shared/async_await_error_codes.dart'
@@ skipping 381 matching lines @@
   ///
   /// - _storeIfNecessary(someLiteral) returns someLiteral.
   /// - _storeIfNecessary(someVariable)
   ///   inserts: var tempX = someVariable
   ///   returns: tempX
   ///   where tempX is a fresh temporary variable.
   js.Expression _storeIfNecessary(js.Expression result) {
     // Note that RegExes, js.ArrayInitializer and js.ObjectInitializer are not
     // [js.Literal]s.
     if (result is js.Literal) return result;
+
     js.Expression tempVar = useTempVar(allocateTempVar());
     addStatement(js.js.statement('# = #;', [tempVar, result]));
     return tempVar;
   }
 
+
+  /// Like [_storeIfNecessary] but binds JavaScript `this` of the function if
+  /// the receiver is a [js.PropertyAccess].
+  /// This is necessary because we cannot translate `a.b()` to:
+  ///     temp = a.b;

[floitsch, 2015/03/06 16:32:15]

nit: make sure that this mark-downs right. (maybe needs a new line)

+  ///     temp();
+  /// This leaves `this` unbound in the call. Take care to bind a

[floitsch, 2015/03/06 16:32:15]

ditto here.

+  js.Expression _storeAndBindIfNecessary(js.Expression result) {
+    // Note that RegExes, js.ArrayInitializer and js.ObjectInitializer are not
+    // [js.Literal]s.
+    if (result is js.Literal) return result;
+    if (result is js.PropertyAccess) {
+      js.Expression tempVar = useTempVar(allocateTempVar());
+      addStatement(js.js.statement('# = #', [tempVar, result.receiver]));
+      addStatement(js.js.statement('# = #.#.bind(#)', [
+        tempVar, tempVar, result.selector, tempVar
+      ]));
+      return tempVar;
+    }
+
+    js.Expression tempVar = useTempVar(allocateTempVar());
+    addStatement(js.js.statement('# = #;', [tempVar, result]));
+    return tempVar;
+  }
+
+  // TODO(sigurdm): This is obsolete - all calls use store: false. Replace with
+  // visitExpression(node);
   withExpression(js.Expression node, fn(js.Expression result), {bool store}) {
     int oldTempVarIndex = currentTempVarIndex;
     js.Expression visited = visitExpression(node);
     if (store) {
       visited = _storeIfNecessary(visited);
     }
     var result = fn(visited);
     currentTempVarIndex = oldTempVarIndex;
     return result;
   }
 
+  withExpressionBinding(js.Expression node,
+                        fn(js.Expression result), {bool store}) {
+    int oldTempVarIndex = currentTempVarIndex;
+    js.Expression visited = visitExpression(node);
+    if (store) {
+      visited = _storeAndBindIfNecessary(visited);
+    }
+    var result = fn(visited);
+    currentTempVarIndex = oldTempVarIndex;
+    return result;
+  }
+
+
   /// Calls [fn] with the value of evaluating [node1] and [node2].
   ///
   /// If `shouldTransform(node2)` the first expression is stored in a temporary
   /// variable.
   ///
   /// This is because node1 must be evaluated before visiting node2,
   /// because the evaluation of an await or yield cannot be expressed as
   /// an expression, visiting node2 it will output statements that
   /// might have an influence on the value of node1.
   withExpression2(js.Expression node1, js.Expression node2,
@@ skipping 369 matching lines @@
     if (!shouldTransform(target)) {
       addStatement(node);
       return;
     }
     translateJump(target, breakLabels[target]);
   }
 
   @override
   js.Expression visitCall(js.Call node) {
     bool storeTarget = node.arguments.any(shouldTransform);
-    return withExpression(node.target, (target) {
+    return withExpressionBinding(node.target, (target) {
       return withExpressions(node.arguments, (List<js.Expression> arguments) {
         return new js.Call(target, arguments);
       });
     }, store: storeTarget);
   }
 
   @override
   void visitCase(js.Case node) {
     return unreachable(node);
   }
@@ skipping 94 matching lines @@
 
   @override
   void visitDefault(js.Default node) => unreachable(node);
 
   @override
   void visitDo(js.Do node) {
     if (!shouldTransform(node)) {
       bool oldInsideUntranslatedBreakable = insideUntranslatedBreakable;
       insideUntranslatedBreakable = true;
       withExpression(node.condition, (js.Expression condition) {
-        addStatement(js.js.statement('do {#} while (#)', [node.body, condition]));
+        addStatement(js.js.statement('do {#} while (#)',
+                                     [node.body, condition]));
       }, store: false);
       insideUntranslatedBreakable = oldInsideUntranslatedBreakable;
       return;
     }
     int startLabel = newLabel("do body");
 
     int continueLabel = newLabel("do condition");
     continueLabels[node] = continueLabel;
 
     int afterLabel = newLabel("after do");
@@ skipping 207 matching lines @@
   js.Expression visitLiteralString(js.LiteralString node) => node;
 
   @override
   visitNamedFunction(js.NamedFunction node) {
     unsupported(node);
   }
 
   @override
   js.Expression visitNew(js.New node) {
     bool storeTarget = node.arguments.any(shouldTransform);
-    return withExpression(node.target, (target) {
+    return withExpressionBinding(node.target, (target) {
       return withExpressions(node.arguments, (List<js.Expression> arguments) {
         return new js.New(target, arguments);
       });
     }, store: storeTarget);
   }
 
   @override
   js.Expression visitObjectInitializer(js.ObjectInitializer node) {
     return withExpressions(
         node.properties.map((js.Property property) => property.value).toList(),
@@ skipping 607 matching lines @@
       addStatement(new js.Return(expression));
     }
   }
 
   @override
   js.Fun finishFunction(List<js.Parameter> parameters,
                         js.Statement rewrittenBody,
                         js.VariableDeclarationList variableDeclarations) {
     // Each iterator invocation on the iterable should work on its own copy of
     // the parameters.
-    // TODO(sigurdm): We only need to do this copying for parameters that are mutated.
+    // TODO(sigurdm): We only need to do this copying for parameters that are
+    // mutated.
     List<js.VariableInitialization> declarations =
         new List<js.VariableInitialization>();
     List<js.Parameter> renamedParameters = new List<js.Parameter>();
     for (js.Parameter parameter in parameters) {
       String name = parameter.name;
       String renamedName = freshName(name);
       renamedParameters.add(new js.Parameter(renamedName));
       declarations.add(
           new js.VariableInitialization(new js.VariableDeclaration(name),
                                         new js.VariableUse(renamedName)));
@@ skipping 685 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }