Use temporary variable for StoreIndexed that returns a value.

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 4821 matching lines @@
   AstNode* loop_var_assignment = NULL;
   if (loop_var != NULL) {
     // The for loop declares a new variable. Add it to the loop body scope.
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment =
         new StoreLocalNode(loop_var_pos, *loop_var, iterator_next);
   } else {
     AstNode* loop_var_primary = ResolveVarOrField(loop_var_pos, *loop_var_name);
     ASSERT(!loop_var_primary->IsPrimaryNode());
     loop_var_assignment =
-        loop_var_primary->MakeAssignmentNode(iterator_next);
+        CreateAssignmentNode(loop_var_primary, iterator_next);
     if (loop_var_assignment == NULL) {
       ErrorMsg(loop_var_pos, "variable or field '%s' is not assignable",
                loop_var_name->ToCString());
     }
   }
   current_block_->statements->Add(loop_var_assignment);
 
   // Now parse the for-in loop statement or block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
@@ skipping 1249 matching lines @@
                                           new LoadLocalNode(token_index, *temp),
                                           right_node->field_name());
     }
     *expr = right_node;
     return left_node;
   }
   return *expr;
 }
 
 
+// Ensure that the expression temp is allocated for nodes that may need it.
+AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
+  AstNode* result = original->MakeAssignmentNode(rhs);
+  if ((result != NULL) && result->IsStoreIndexedNode()) {
+    EnsureExpressionTemp();
+  }
+  return result;
+}
+
+
 AstNode* Parser::ParseExpr(bool require_compiletime_const) {
   TRACE_PARSER("ParseExpr");
   const intptr_t expr_pos = token_index_;
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     }
     return expr;
   }
   // Assignment expressions.
   Token::Kind assignment_op = CurrentToken();
   const intptr_t assignment_pos = token_index_;
   ConsumeToken();
   const intptr_t right_expr_pos = token_index_;
   if (require_compiletime_const && (assignment_op != Token::kASSIGN)) {
     ErrorMsg(right_expr_pos, "expression must be a compile time constant");
   }
   AstNode* right_expr = ParseExpr(require_compiletime_const);
   AstNode* left_expr = expr;
   if (assignment_op != Token::kASSIGN) {
     // Compound assignment: store inputs with side effects into temp. locals.
     left_expr = PrepareCompoundAssignmentNodes(&expr);
   }
   right_expr =
       ExpandAssignableOp(assignment_pos, assignment_op, expr, right_expr);
-  AstNode* assign_expr = left_expr->MakeAssignmentNode(right_expr);
+  AstNode* assign_expr = CreateAssignmentNode(left_expr, right_expr);
   if (assign_expr == NULL) {
     ErrorMsg(assignment_pos,
              "left hand side of '%s' is not assignable",
              Token::Str(assignment_op));
   }
   return assign_expr;
 }
 
 
 LiteralNode* Parser::ParseConstExpr() {
@@ skipping 46 matching lines @@
     }
     // 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);
+    AstNode* store = CreateAssignmentNode(left_expr, add);
     expr = store;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
 
 ArgumentListNode* Parser::ParseActualParameters(
                               ArgumentListNode* implicit_arguments,
@@ skipping 144 matching lines @@
     ConsumeToken();
     AstNode* value = ParseExpr(kAllowConst);
     AstNode* load_access =
         new InstanceGetterNode(call_pos, receiver, field_name);
     AstNode* left_load_access = load_access;
     if (assignment_op != Token::kASSIGN) {
       // Compound assignment: store inputs with side effects into temp. locals.
       left_load_access = PrepareCompoundAssignmentNodes(&load_access);
     }
     value = ExpandAssignableOp(call_pos, assignment_op, load_access, value);
-    access = left_load_access->MakeAssignmentNode(value);
+    access = CreateAssignmentNode(left_load_access, value);
   } else {
     access = CallGetter(call_pos, receiver, field_name);
   }
   return access;
 }
 
 
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
                                            intptr_t ident_pos) {
   // If the static field has an initializer, initialize the field at compile
@@ skipping 62 matching lines @@
         // Field has been marked as final, report an error as the field
         // is not settable.
         ErrorMsg(ident_pos,
                  "field '%s' is const static, cannot assign to it",
                  field_name.ToCString());
         return access;
       }
       load_access = GenerateStaticFieldLookup(field, token_index_);
     }
     value = ExpandAssignableOp(call_pos, assignment_op, load_access, value);
-    access = load_access->MakeAssignmentNode(value);
+    access = CreateAssignmentNode(load_access, value);
   } else {  // Not Token::IsAssignmentOperator(CurrentToken()).
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(field_name));
       const int kNumArguments = 0;  // no arguments.
       const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
@@ skipping 222 matching lines @@
     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);
+    AstNode* store = CreateAssignmentNode(left_expr, 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.
@@ skipping 1799 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart