Simplify AST by extending LetNode and replace CommaNode.

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 1417 matching lines @@
       Array::ZoneHandle(ArgumentsDescriptor::New(function_args.length(),
                                                  function_args.names()));
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
   // The third argument is an array containing the original function arguments,
   // including the receiver.
   ArrayNode* args_array =
       new ArrayNode(args_pos, Type::ZoneHandle(Type::ArrayType()));
   for (intptr_t i = 0; i < function_args.length(); i++) {
     AstNode* arg = function_args.NodeAt(i);
     if ((temp_for_last_arg != NULL) && (i == function_args.length() - 1)) {
-      args_array->AddElement(
-          new CommaNode(arg->token_pos(),
-                        new StoreLocalNode(arg->token_pos(),
+      LetNode* store_arg = new LetNode(arg->token_pos());
+      store_arg->AddNode(new StoreLocalNode(arg->token_pos(),
                                            temp_for_last_arg,
-                                           arg),
-                        new LoadLocalNode(arg->token_pos(),
-                                          temp_for_last_arg)));
+                                           arg));
+      store_arg->AddNode(new LoadLocalNode(arg->token_pos(),
+                                           temp_for_last_arg));
+      args_array->AddElement(store_arg);
     } else {
-      args_array->AddElement(function_args.NodeAt(i));
+      args_array->AddElement(arg);
     }
   }
   arguments->Add(args_array);
   // Lookup the static InvocationMirror._allocateInvocationMirror method.
   const Class& mirror_class =
       Class::Handle(LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       mirror_class.LookupStaticFunction(
           PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
@@ skipping 5617 matching lines @@
        result->IsStoreStaticFieldNode() ||
        result->IsStoreLocalNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
-  LetNode* result = new LetNode(cascade_pos);
-  LocalVariable* cascade_receiver_var = result->AddInitializer(expr);
-  // TODO(fschneider): Make LetNode support more than one body node and
-  // replace the SequenceNode here and CommaNode here and in postfix
-  // expressions.
-  SequenceNode* cascade = new SequenceNode(cascade_pos, NULL);
+  LetNode* cascade = new LetNode(cascade_pos);
+  LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
         new LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
     } else if (LookaheadToken(1) == Token::kLBRACK) {
       ConsumeToken();
     } else {
@@ skipping 13 matching lines @@
         // temporary locals.
         LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
         AstNode* assign_expr = CreateAssignmentNode(expr, right_expr);
         if (assign_expr == NULL) {
           ErrorMsg(assignment_pos,
                    "left hand side of '%s' is not assignable",
                    Token::Str(assignment_op));
         }
-        let_expr->set_body(assign_expr);
+        let_expr->AddNode(assign_expr);
         expr = let_expr;
       } else {
         right_expr =
             ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
         AstNode* assign_expr = CreateAssignmentNode(expr, right_expr);
         if (assign_expr == NULL) {
           ErrorMsg(assignment_pos,
                    "left hand side of '%s' is not assignable",
                    Token::Str(assignment_op));
         }
         expr = assign_expr;
       }
     }
-    cascade->Add(expr);
+    cascade->AddNode(expr);
   }
-  // The result is a pair of the (side effects of the) cascade sequence
-  // followed by the (value of the) receiver temp variable load.
-  CommaNode* body = new CommaNode(
-      cascade_pos,
-      cascade,
-      new LoadLocalNode(cascade_pos, cascade_receiver_var));
-  result->set_body(body);
-  return result;
+  // The result is an expression with the (side effects of the) cascade
+  // sequence followed by the (value of the) receiver temp variable load.
+  cascade->AddNode(new LoadLocalNode(cascade_pos, cascade_receiver_var));
+  return cascade;
 }
 
 
 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 24 matching lines @@
     // Compound assignment: store inputs with side effects into temp. locals.
     LetNode* let_expr = PrepareCompoundAssignmentNodes(&expr);
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
     AstNode* assign_expr = CreateAssignmentNode(expr, assigned_value);
     if (assign_expr == NULL) {
       ErrorMsg(assignment_pos,
                "left hand side of '%s' is not assignable",
                Token::Str(assignment_op));
     }
-    let_expr->set_body(assign_expr);
+    let_expr->AddNode(assign_expr);
     return let_expr;
   } else {
     AstNode* assigned_value =
         ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
     AstNode* assign_expr = CreateAssignmentNode(expr, assigned_value);
     if (assign_expr == NULL) {
       ErrorMsg(assignment_pos,
                "left hand side of '%s' is not assignable",
                Token::Str(assignment_op));
     }
@@ skipping 59 matching lines @@
     LetNode* let_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 = CreateAssignmentNode(expr, add);
     ASSERT(store != NULL);
-    let_expr->set_body(store);
+    let_expr->AddNode(store);
     expr = let_expr;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
 ArgumentListNode* Parser::ParseActualParameters(
                               ArgumentListNode* implicit_arguments,
@@ skipping 475 matching lines @@
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new BinaryOpNode(
         postfix_expr_pos,
         binary_op,
         new LoadLocalNode(postfix_expr_pos, temp),
         new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
     AstNode* store = CreateAssignmentNode(postfix_expr, add);
     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.
-    let_expr->set_body(new CommaNode(
-        postfix_expr_pos,
-        store,
-        new LoadLocalNode(postfix_expr_pos, temp)));
+    let_expr->AddNode(store);
+    let_expr->AddNode(new LoadLocalNode(postfix_expr_pos, temp));
     return let_expr;
   }
   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.
@@ skipping 2200 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart