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;
   }
 
+  // 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;
   }
 
+  /// Calls [fn] with the result of evaluating [node]. Taking special care of
+  /// property accesses.
+  ///
+  /// If [store] is true the result of evaluating [node] is stored in a
+  /// temporary.
+  ///
+  /// We cannot rewrite `<receiver>.m()` to:
+  ///     temp = <receiver>.m;

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

Make sure this is correct MD.

[sigurdm, 2015/03/09 14:34:11]

Yes - indenting by 4 gives a code block

+  ///     temp();
+  /// Because this leaves `this` unbound in the call. But because dart2js never
+  /// changes function properties we write:

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

Make sure to write a test for this.

Something like:

class A {
  var f;
}

foo(x) => 499;
bar(x) => 42;

change(x) {
  x.f = (x) => 99;
}

main() {
  var a = confuse(new A(foo));
  var a2 =  confuse(new A(bar));
  a.f(await change(a));
}

Maybe find other similar examples.

[sigurdm, 2015/03/09 14:34:12]

Done.

+  ///     temp = <receiver>;
+  ///     temp.m();
+  withExpressionDontStoreFunction(js.Expression node,

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

I don't get the name.

[sigurdm, 2015/03/09 14:34:12]

I changed it. Hopefully better.

+                        fn(js.Expression result), {bool store}) {
+    int oldTempVarIndex = currentTempVarIndex;
+    js.Expression visited = visitExpression(node);
+    js.Expression selector;
+    if (store) {
+      if (visited is js.PropertyAccess) {
+        js.PropertyAccess propertyAccess = visited;
+        selector = propertyAccess.selector;
+        visited = propertyAccess.receiver;
+      }
+      visited = _storeIfNecessary(visited);

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

Avoid updating visited.
Rather have a new variable (ideally with a name that indicates what is
different.)

[sigurdm, 2015/03/09 14:34:11]

Done.

+    }
+    js.Expression result;
+    if (selector == null) {
+      result = fn(visited);
+    } else {
+      result = fn(new js.PropertyAccess(visited, selector));
+    }
+    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 370 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 withExpressionDontStoreFunction(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 withExpressionDontStoreFunction(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 608 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;
   }
 }