When += (and similar operations) are converted to = + ,

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 1786 matching lines @@
 
     return target.invoke(this, name, position, _makeArgs(node.arguments));
   }
 
   visitIndexExpression(IndexExpression node) {
     var target = visitValue(node.target);
     var index = visitValue(node.index);
     return target.invoke(this, ':index', node, new Arguments(null, [index]));
   }
 
+  bool _expressionNeedsParens(Expression e) {
+    return (e is BinaryExpression || e is ConditionalExpression
+            || e is PostfixExpression || _isUnaryIncrement(e));
+  }
+
   visitBinaryExpression(BinaryExpression node, [bool isVoid = false]) {
     final kind = node.op.kind;
     // TODO(jimhug): Ensure these have same semantics as JS!
     if (kind == TokenKind.AND || kind == TokenKind.OR) {
       var x = visitTypedValue(node.x, world.nonNullBool);
       var y = visitTypedValue(node.y, world.nonNullBool);
       final code = '${x.code} ${node.op} ${y.code}';
       if (x.isConst && y.isConst) {
         var value = (kind == TokenKind.AND)
             ? x.actualValue && y.actualValue : x.actualValue || y.actualValue;
@@ skipping 46 matching lines @@
       final y = visitValue(node.y);
       var name = TokenKind.binaryMethodName(node.op.kind);
       if (node.op.kind == TokenKind.NE) {
         name = ':ne';
       }
       if (name == null) {
         world.internalError('unimplemented binary op ${node.op}', node.span);
         return;
       }
       return x.invoke(this, name, node, new Arguments(null, [y]));
-    } else {
+    } else if ((assignKind != 0) && _expressionNeedsParens(node.y)) {
+      return _visitAssign(assignKind, node.x,
+          new ParenExpression(node.y, node.y.span), node, null, isVoid);
+    } else {  
       return _visitAssign(assignKind, node.x, node.y, node, null, isVoid);
     }
   }
 
   /**
    * Visits an assignment expression.
    * Note: captureOriginal can optionally capture the original value of the
    * left side. This is used by postfix expressions to ensure they return the
    * original value, before it has been modified.
    */
@@ skipping 497 matching lines @@
     if (node.value is List) {
       var items = [];
       for (var item in node.value) {
         var val = visitValue(item);
         val.invoke(this, 'toString', item, Arguments.EMPTY);
 
         // TODO(jimhug): Ensure this solves all precedence problems.
         // TODO(jmesserly): We could be smarter about prefix/postfix, but we'd
         // need to know if it will compile to a ++ or to some sort of += form.
         var code = val.code;
-        if (item is BinaryExpression || item is ConditionalExpression
-            || item is PostfixExpression || _isUnaryIncrement(item)) {
+        if (_expressionNeedsParens(item)) {
           code = '(${code})';
         }
         // No need to concat empty strings except the first.
         if (items.length == 0 || (code != "''" && code != '""')) {
           items.add(code);
         }
       }
       return new Value(type, '(${Strings.join(items, " + ")})', node.span);
     }
 
@@ skipping 135 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }