Removing all incr-op nodes.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 6135 matching lines @@
     } else {
       expr = UnaryOpNode::UnaryOpOrLiteral(op_pos, unary_op, expr);
     }
   } else if (IsIncrementOperator(CurrentToken())) {
     Token::Kind incr_op = CurrentToken();
     ConsumeToken();
     expr = ParseUnaryExpr();
     if (!IsAssignableExpr(expr)) {
       ErrorMsg("expression is not assignable");
     }
-    // TODO(srdjan): Implement transformation for all.
-    if (expr->IsLoadStaticFieldNode() || expr->IsStaticGetterNode()) {
-      Token::Kind binary_op =
-          (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
-      BinaryOpNode* add = new BinaryOpNode(
-          op_pos,
-          binary_op,
-          expr,
-          new LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
-      AstNode* store = expr->MakeAssignmentNode(add);
-      expr = store;
-    } else {
-      // is_prefix.
-      AstNode* incr_op_node = expr->MakeIncrOpNode(op_pos, incr_op, true);
-      if (incr_op_node == NULL) {
-        Unimplemented("incr operation not implemented");
-      }
-      expr = incr_op_node;
-    }
+    // Is prefix.
+    AstNode* left_expr = PrepareCompoundAssignmentNodes(&expr);
+    Token::Kind binary_op =
+        (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
+    BinaryOpNode* add = new BinaryOpNode(
+        op_pos,
+        binary_op,
+        expr,
+        new LiteralNode(op_pos, Smi::ZoneHandle(Smi::New(1))));
+    AstNode* store = left_expr->MakeAssignmentNode(add);
+    expr = store;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
 ArgumentListNode* Parser::ParseActualParameters(
                               ArgumentListNode* implicit_arguments,
                               bool require_const) {
@@ skipping 455 matching lines @@
     postfix_expr = selector;
   }
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
     if (!IsAssignableExpr(postfix_expr)) {
       ErrorMsg("expression is not assignable");
     }
     ConsumeToken();
     // Not prefix.
-    if (postfix_expr->IsLoadStaticFieldNode() ||
-        postfix_expr->IsStaticGetterNode() ||
-        postfix_expr->IsLoadLocalNode()) {
-      const LocalVariable& temp = GetIncrementTempLocal();
-      AstNode* save =
-          new StoreLocalNode(postfix_expr_pos, temp, postfix_expr);
-      Token::Kind binary_op =
-          (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
-      BinaryOpNode* add = new BinaryOpNode(
-          postfix_expr_pos,
-          binary_op,
-          save,
-          new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
-      AstNode* store = postfix_expr->MakeAssignmentNode(add);
-      LoadLocalNode* load_res =
-          new LoadLocalNode(postfix_expr_pos, temp, store);
-      return load_res;
-    } else {
-      AstNode* incr_op_node =
-          postfix_expr->MakeIncrOpNode(postfix_expr_pos, incr_op, false);
-      if (incr_op_node == NULL) {
-        Unimplemented("incr op not implemented");
-      }
-      postfix_expr = incr_op_node;
-    }
+    AstNode* left_expr = PrepareCompoundAssignmentNodes(&postfix_expr);
+    const LocalVariable& temp = GetIncrementTempLocal();
+    AstNode* save =
+        new StoreLocalNode(postfix_expr_pos, temp, postfix_expr);
+    Token::Kind binary_op =
+        (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
+    BinaryOpNode* add = new BinaryOpNode(
+        postfix_expr_pos,
+        binary_op,
+        save,
+        new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
+    AstNode* store = left_expr->MakeAssignmentNode(add);
+    LoadLocalNode* load_res =
+        new LoadLocalNode(postfix_expr_pos, temp, store);
+    return load_res;
   }
   return postfix_expr;
 }
 
 
 // Resolve the given type and its type arguments from the given scope class
 // according to the given type finalization mode.
 // If the given scope class is null, use the current library, but do not try to
 // resolve type parameters.
 // Not all involved type classes may get resolved yet, but at least the type
@@ skipping 1763 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart