Eliminate IncrOpStaticFieldNode, replace a set of 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 1681 matching lines @@
     // The temporary variables are necessary so that the argument
     // expressions are not evaluated twice.
     ArgumentListNode* ctor_args = super_call->arguments();
     // The super initializer call has at least 2 arguments: the
     // implicit receiver, and the hidden construction phase.
     ASSERT(ctor_args->length() >= 2);
     for (int i = 2; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
       if (!arg->IsLoadLocalNode() && !arg->IsLiteralNode()) {
         LocalVariable* temp =
-        CreateTempConstVariable(arg->token_index(), arg->id(), "sca");
+            CreateTempConstVariable(arg->token_index(), arg->id(), "sca");
         AstNode* save_temp =
-        new StoreLocalNode(arg->token_index(), *temp, arg);
+            new StoreLocalNode(arg->token_index(), *temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
     ArgumentListNode* initializer_args = super_call->arguments();
     const Function& super_ctor = super_call->function();
@@ skipping 2459 matching lines @@
 }
 
 
 void Parser::ParseStatementSequence() {
   TRACE_PARSER("ParseStatementSequence");
   const bool dead_code_allowed = true;
   bool abrupt_completing_seen = false;
   while (CurrentToken() != Token::kRBRACE) {
     const intptr_t statement_pos = token_index_;
     AstNode* statement = ParseStatement();
-    if (statement != NULL) {
+    // Do not add statements with no effect (e.g., LoadLocalNode).
+    if (statement != NULL && !statement->IsLoadLocalNode()) {
       if (!dead_code_allowed && abrupt_completing_seen) {
         ErrorMsg(statement_pos, "dead code after abrupt completing statement");
       }
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
 }
 
 
@@ skipping 1652 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");
     }
-    // is_prefix.
-    AstNode* incr_op_node = expr->MakeIncrOpNode(op_pos, incr_op, true);
-    if (incr_op_node == NULL) {
-      Unimplemented("incr operation not implemented");
+    // TODO(srdjan): Implement transformation for all.
+    if (expr->IsLoadStaticFieldNode() || expr->IsStaticGetterNode()) {
+      LocalVariable* temp =

[hausner, 2012/03/06 23:44:13]

I'm not sure why we need a temp variable at all. Is it not sufficient to build
an ast branch like this (assuming ++ of the static field x in class C):

StaticSetterNode(C.x, BinaryOpNode(+, StaticGetterNode(C.x), 1)

[srdjan, 2012/03/07 00:19:28]

That is correct. Changed.

+          CreateTempConstVariable(op_pos, expr->id(), "incoplix");
+      AstNode* save =
+          new StoreLocalNode(op_pos, *temp, expr);
+      current_block_->statements->Add(save);
+      LoadLocalNode* load = new LoadLocalNode(op_pos, *temp);
+      Token::Kind binary_op =
+          (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
+      BinaryOpNode* add = new BinaryOpNode(
+          op_pos,
+          binary_op,
+          load,
+          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;
     }
-    expr = incr_op_node;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
 ArgumentListNode* Parser::ParseActualParameters(
                               ArgumentListNode* implicit_arguments,
                               bool require_const) {
@@ skipping 444 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.
-    AstNode* incr_op_node =
-        postfix_expr->MakeIncrOpNode(postfix_expr_pos, incr_op, false);
-    if (incr_op_node == NULL) {
-      Unimplemented("incr op not implemented");
+    if (postfix_expr->IsLoadStaticFieldNode() ||
+        postfix_expr->IsStaticGetterNode()) {
+      LocalVariable* temp = CreateTempConstVariable(
+          postfix_expr_pos, postfix_expr->id(), "incoplix");
+      AstNode* save =
+          new StoreLocalNode(postfix_expr_pos, *temp, postfix_expr);
+      current_block_->statements->Add(save);
+      LoadLocalNode* load = new LoadLocalNode(postfix_expr_pos, *temp);
+      Token::Kind binary_op =
+          (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
+      BinaryOpNode* add = new BinaryOpNode(
+          postfix_expr_pos,
+          binary_op,
+          load,
+          new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
+      AstNode* store = postfix_expr->MakeAssignmentNode(add);
+      current_block_->statements->Add(store);
+      LoadLocalNode* load_res = new LoadLocalNode(postfix_expr_pos, *temp);
+      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;
     }
-    postfix_expr = incr_op_node;
   }
   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 1711 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart