Remove pseudo-node from LoadLocalNode and replace it with a proper AST node.

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 1499 matching lines @@
   if (is_no_such_method) {
     arguments = BuildNoSuchMethodArguments(
         supercall_pos, function_name, *arguments);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
 // Simple test if a node is side effect free.
 static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
-  if (node->IsLiteralNode()) {
-    return true;
-  }
-  if (node->IsLoadLocalNode() && !node->AsLoadLocalNode()->HasPseudo()) {
-    return true;
-  }
-  return false;
+  return node->IsLiteralNode() || node->IsLoadLocalNode();
 }
 
 
 AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
   ASSERT(super->IsSuper());
   AstNode* super_op = NULL;
   const intptr_t super_pos = super->token_pos();
   if ((op == Token::kNEGATE) ||
       (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
@@ skipping 3873 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 = TokenPos();
     AstNode* statement = ParseStatement();
     // Do not add statements with no effect (e.g., LoadLocalNode).
     if ((statement != NULL) && statement->IsLoadLocalNode()) {
       // Skip load local.
-      statement = statement->AsLoadLocalNode()->pseudo();
+      continue;
     }
     if (statement != NULL) {
       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 1445 matching lines @@
             op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
 bool Parser::IsAssignableExpr(AstNode* expr) {
-  return (expr->IsLoadLocalNode() && !expr->AsLoadLocalNode()->HasPseudo()
+  return (expr->IsLoadLocalNode()
           && (!expr->AsLoadLocalNode()->local().is_final()))
       || expr->IsLoadStaticFieldNode()
       || expr->IsStaticGetterNode()
       || expr->IsInstanceGetterNode()
       || expr->IsLoadIndexedNode()
       || (expr->IsPrimaryNode() && !expr->AsPrimaryNode()->IsSuper());
 }
 
 
 AstNode* Parser::ParseExprList() {
@@ skipping 272 matching lines @@
         ErrorMsg(assignment_pos,
                  "left hand side of '%s' is not assignable",
                  Token::Str(assignment_op));
       }
       expr = assign_expr;
     }
     cascade->Add(expr);
   }
   // The result is a pair of the (side effects of the) cascade sequence
   // followed by the (value of the) receiver temp variable load.
-  return new LoadLocalNode(cascade_pos, cascade_receiver_var, cascade);
+  return new CommaNode(
+      cascade_pos,
+      cascade,
+      new LoadLocalNode(cascade_pos, cascade_receiver_var));
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   const intptr_t expr_pos = TokenPos();
 
   if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
@@ skipping 590 matching lines @@
     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 = CreateAssignmentNode(left_expr, add);
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.
-    LoadLocalNode* load_res =
-        new LoadLocalNode(postfix_expr_pos, temp, store);
-    return load_res;
+    return new CommaNode(
+        postfix_expr_pos,
+        store,
+        new LoadLocalNode(postfix_expr_pos, temp));
   }
   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 2187 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart