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 1852 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 {
-      return _visitAssign(assignKind, node.x, node.y, node, null, isVoid);
-    }
+    } else if ((assignKind != 0) && (node.y is BinaryExpression)){
+      BinaryExpression y = node.y;
+      if (TokenKind.infixPrecedence(y.op.kind) <=
+          TokenKind.infixPrecedence(assignKind)) {

[jimhug, 2011/12/15 17:43:18]

I would prefer not to include this check.  My general rule is that if you need
to think about precedence very hard then it is better to include parens.  This
check is relying on js and dart precedences to be identical - which I would have
to verify before guaranteeing.  Does this change make a big difference to the
generated code?

[dgrove, 2011/12/15 17:51:45]

It doesn't any changes in minfrog, for instance. It could make some generated JS
a bit less readable, but that could be a reasonable price to pay.

I'm going to take this out, and we can always make this smarter if we need to.
On 2011/12/15 17:43:18, jimhug wrote:

[dgrove, 2011/12/15 17:51:45]

Done.

+        // This handles transforming A x= B y C => A = A x (B y C) when
+        // precedence of x >= precedence of y. 
+        return _visitAssign(assignKind, node.x,
+            new ParenExpression(node.y, node.y.span), node, null, isVoid);
+      } 
+    }  
+    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.
    */
   _visitAssign(int kind, Expression xn, Expression yn, Node position,
       Value captureOriginal(Value right), [bool isVoid = false]) {
@@ skipping 652 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);
   }
 }