Fix renaming of exception variables on left-hand-sides.

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 731 matching lines @@
 
   @override
   js.Expression visitAssignment(js.Assignment node) {
     if (!shouldTransform(node)) {
       return new js.Assignment.compound(visitExpression(node.leftHandSide),
           node.op, visitExpression(node.value));
     }
     js.Expression leftHandSide = node.leftHandSide;
     if (leftHandSide is js.VariableUse) {
       return withExpression(node.value, (js.Expression value) {
-        return new js.Assignment(leftHandSide, value);
+        // A non-compound [js.Assignment] has `op==null`. So it works out to
+        // use [js.Assignment.compound] for all cases.
+        // Visit the [js.VariableUse] to ensure renaming is done correctly.
+        return new js.Assignment.compound(visitExpression(leftHandSide),
+                                          node.op,
+                                          value);
       }, store: false);
     } else if (leftHandSide is js.PropertyAccess) {
       return withExpressions([
         leftHandSide.receiver,
         leftHandSide.selector,
         node.value
       ], (evaluated) {
         return new js.Assignment.compound(
             new js.PropertyAccess(evaluated[0], evaluated[1]), node.op,
             evaluated[2]);
@@ skipping 441 matching lines @@
   }
 
   @override
   visitParameter(js.Parameter node) => unreachable(node);
 
   @override
   js.Expression visitPostfix(js.Postfix node) {
     if (node.op == "++" || node.op == "--") {
       js.Expression argument = node.argument;
       if (argument is js.VariableUse) {
-        return new js.Postfix(node.op, argument);
+        return new js.Postfix(node.op, visitExpression(argument));
       } else if (argument is js.PropertyAccess) {
         return withExpression2(argument.receiver, argument.selector,
             (receiver, selector) {
           return new js.Postfix(
               node.op, new js.PropertyAccess(receiver, selector));
         });
       } else {
         throw "Unexpected postfix ${node.op} "
             "operator argument ${node.argument}";
       }
     }
     return withExpression(node.argument,
         (js.Expression argument) => new js.Postfix(node.op, argument),
         store: false);
   }
 
   @override
   js.Expression visitPrefix(js.Prefix node) {
     if (node.op == "++" || node.op == "--") {
       js.Expression argument = node.argument;
       if (argument is js.VariableUse) {
-        return new js.Prefix(node.op, argument);
+        return new js.Prefix(node.op, visitExpression(argument));
       } else if (argument is js.PropertyAccess) {
         return withExpression2(argument.receiver, argument.selector,
             (receiver, selector) {
           return new js.Prefix(
               node.op, new js.PropertyAccess(receiver, selector));
         });
       } else {
         throw "Unexpected prefix ${node.op} operator "
             "argument ${node.argument}";
       }
@@ skipping 274 matching lines @@
     beginLabel(afterFinallyLabel);
   }
 
   @override
   visitVariableDeclaration(js.VariableDeclaration node) {
     unreachable(node);
   }
 
   @override
   js.Expression visitVariableDeclarationList(js.VariableDeclarationList node) {
-    List<js.Assignment> initializations = new List<js.Assignment>();
+    List<js.Expression> initializations = new List<js.Expression>();
 
     // Declaration of local variables is hoisted outside the helper but the
     // initialization is done here.
     for (js.VariableInitialization initialization in node.declarations) {
       js.VariableDeclaration declaration = initialization.declaration;
       localVariables.add(declaration);
       if (initialization.value != null) {
         withExpression(initialization.value, (js.Expression value) {
           initializations.add(
               new js.Assignment(new js.VariableUse(declaration.name), value));
@@ skipping 987 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }