Fix ??= AST modification

runtime/vm/parser.cc

Index: runtime/vm/parser.cc
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index 23c22c3f3fc03cff02cb1eb625772e0568201306..be67426c8d9ec38516765244cff7e6d3a9221567 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -8644,6 +8644,7 @@ AstNode* Parser::ParseAwaitForStatement(String* label_name) {
     ASSERT(!loop_var_primary->IsPrimaryNode());
     loop_var_assignment = CreateAssignmentNode(loop_var_primary,
                                                iterator_current,
+                                               false,

[srdjan, 2015/08/11 19:26:10]

Add comment /*is_compound */

                                                loop_var_name,
                                                loop_var_assignment_pos);
     ASSERT(loop_var_assignment != NULL);
@@ -8862,6 +8863,7 @@ AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
     ASSERT(!loop_var_primary->IsPrimaryNode());
     loop_var_assignment = CreateAssignmentNode(loop_var_primary,
                                                iterator_current,
+                                               false,

[srdjan, 2015/08/11 19:26:10]

ditto

                                                loop_var_name,
                                                loop_var_assignment_pos);
     ASSERT(loop_var_assignment != NULL);
@@ -10569,6 +10571,7 @@ bool Parser::IsLegalAssignableSyntax(AstNode* expr, intptr_t end_pos) {
 
 AstNode* Parser::CreateAssignmentNode(AstNode* original,
                                       AstNode* rhs,
+                                      bool is_compound,
                                       const String* left_ident,
                                       intptr_t left_pos) {
   AstNode* result = original->MakeAssignmentNode(rhs);
@@ -10608,17 +10611,19 @@ AstNode* Parser::CreateAssignmentNode(AstNode* original,
   // normally: a op= b ==> a = a op b
   // however:  a ??= b ==> a ?? (a = b)
   // Therefore, we need to transform a = (a ?? b) into a ?? (a = b)
-  if (rhs->IsBinaryOpNode() &&
+  if (is_compound &&
+      rhs->IsBinaryOpNode() &&
       (rhs->AsBinaryOpNode()->kind() == Token::kIFNULL)) {
     BinaryOpNode* ifnull = rhs->AsBinaryOpNode();
     AstNode* modified_assign =
-        CreateAssignmentNode(ifnull->left(),
+        CreateAssignmentNode(original,
                              ifnull->right(),
+                             false,

[srdjan, 2015/08/11 19:26:10]

ditto

                              left_ident,
                              left_pos);
     result = new(Z) BinaryOpNode(rhs->token_pos(),
                                  Token::kIFNULL,
-                                 original,
+                                 ifnull->left(),
                                  modified_assign);
   }
   return result;
@@ -10660,7 +10665,7 @@ AstNode* Parser::ParseCascades(AstNode* expr) {
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
         AstNode* assign_expr =
-            CreateAssignmentNode(expr, right_expr, expr_ident, expr_pos);
+            CreateAssignmentNode(expr, right_expr, true, expr_ident, expr_pos);

[srdjan, 2015/08/11 19:26:10]

comment what true means (and below false). Also at other call sites.
Other Idea is to have CreateAssignmentNode and CreateCompundAssignment  methods.

         ASSERT(assign_expr != NULL);
         let_expr->AddNode(assign_expr);
         expr = let_expr;
@@ -10668,7 +10673,7 @@ AstNode* Parser::ParseCascades(AstNode* expr) {
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
         AstNode* assign_expr =
-            CreateAssignmentNode(expr, right_expr, expr_ident, expr_pos);
+            CreateAssignmentNode(expr, right_expr, false, expr_ident, expr_pos);
         ASSERT(assign_expr != NULL);
         expr = assign_expr;
       }
@@ -10773,14 +10778,14 @@ AstNode* Parser::ParseExpr(bool require_compiletime_const,
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
     AstNode* assign_expr =
-        CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
+        CreateAssignmentNode(expr, assigned_value, true, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
     AstNode* assigned_value = LiteralIfStaticConst(Z, right_expr);
     AstNode* assign_expr =
-        CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
+        CreateAssignmentNode(expr, assigned_value, false, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     return assign_expr;
   }
@@ -10874,7 +10879,8 @@ AstNode* Parser::ParseUnaryExpr() {
         binary_op,
         expr,
         new(Z) LiteralNode(op_pos, Smi::ZoneHandle(Z, Smi::New(1))));
-    AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
+    AstNode* store =
+        CreateAssignmentNode(expr, add, true, expr_ident, expr_pos);
     ASSERT(store != NULL);
     let_expr->AddNode(store);
     expr = let_expr;
@@ -11591,7 +11597,8 @@ AstNode* Parser::ParsePostfixExpr() {
         binary_op,
         new(Z) LoadLocalNode(expr_pos, temp),
         new(Z) LiteralNode(expr_pos, Smi::ZoneHandle(Z, Smi::New(1))));
-    AstNode* store = CreateAssignmentNode(expr, add, expr_ident, expr_pos);
+    AstNode* store =
+        CreateAssignmentNode(expr, add, true, expr_ident, expr_pos);
     ASSERT(store != NULL);
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.