Allow assignment expressions in conditional expressions

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 5435 matching lines @@
 
 static bool IsLocalOrLiteralNode(AstNode* node) {
   return node->IsLoadLocalNode() || node->IsLiteralNode();
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_index,
                                                intptr_t token_id,
                                                const char* s) {
   char name[64];
-  OS::SNPrint(name, 64, "%s%d", s, token_id);
+  OS::SNPrint(name, 64, ":%s%d", s, token_id);
   LocalVariable* temp =
       new LocalVariable(token_index,
                         String::ZoneHandle(String::NewSymbol(name)),
                         Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // If 'node' can create side effects, store its result in a temporary variable
 // and return a LoadLocalNode instead.
 // Side effect free nodes are LoadLocalNode and LiteralNode.
 AstNode* Parser::AsSideEffectFreeNode(AstNode* node) {
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     intptr_t token_id = node->id();
     intptr_t token_index = node->token_index();
     node = NULL;  // Do not use it.
+    // The array object access may not have side effects.
+    // First, evaluate the array object expression if it might have side
+    // effects.
+    if (!IsLocalOrLiteralNode(load_indexed->array())) {
+      LocalVariable* temp =
+      CreateTempConstVariable(token_index, token_id, "lia");
+      AstNode* save =
+      new StoreLocalNode(token_index, *temp, load_indexed->array());
+      current_block_->statements->Add(save);
+      AstNode* load = new LoadLocalNode(token_index, *temp);
+      load_indexed = new LoadIndexedNode(token_index,
+                                         load,
+                                         load_indexed->index_expr());
+    }
+    // Second, evaluate the index expression and store in a temporary
+    // variable if it might have side effects.
     if (!IsLocalOrLiteralNode(load_indexed->index_expr())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_index, token_id, "lix");
       AstNode* save =
           new StoreLocalNode(token_index, *temp, load_indexed->index_expr());
       current_block_->statements->Add(save);
       AstNode* load = new LoadLocalNode(token_index, *temp);
       load_indexed = new LoadIndexedNode(token_index,
                                          load_indexed->array(),
                                          load);
     }
-    // The array object access may not have side effects.
-    if (!IsLocalOrLiteralNode(load_indexed->array())) {
-      LocalVariable* temp =
-          CreateTempConstVariable(token_index, token_id, "lia");
-      AstNode* save =
-          new StoreLocalNode(token_index, *temp, load_indexed->array());
-      current_block_->statements->Add(save);
-      AstNode* load = new LoadLocalNode(token_index, *temp);
-      load_indexed = new LoadIndexedNode(token_index,
-                                         load,
-                                         load_indexed->index_expr());
-    }
     return load_indexed;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* getter = node->AsInstanceGetterNode();
     intptr_t token_index = node->token_index();
     intptr_t token_id = node->id();
     node = NULL;  // Do not use it.
     if (!IsLocalOrLiteralNode(getter->receiver())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_index, token_id, "igr");
@@ skipping 127 matching lines @@
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const intptr_t expr_pos = token_index_;
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
   if (CurrentToken() == Token::kCONDITIONAL) {
     ConsumeToken();
-    AstNode* expr1 = ParseConditionalExpr();
+    AstNode* expr1 = ParseExpr(kAllowConst);
     ExpectToken(Token::kCOLON);
-    AstNode* expr2 = ParseConditionalExpr();
+    AstNode* expr2 = ParseExpr(kAllowConst);
     expr = new ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = token_index_;
@@ skipping 2025 matching lines @@
     ConsumeToken();
     SkipUnaryExpr();
   }
 }
 
 
 void Parser::SkipConditionalExpr() {
   SkipBinaryExpr();
   if (CurrentToken() == Token::kCONDITIONAL) {
     ConsumeToken();
-    SkipConditionalExpr();
+    SkipExpr();
     ExpectToken(Token::kCOLON);
-    SkipConditionalExpr();
+    SkipExpr();
   }
 }
 
 
 void Parser::SkipExpr() {
   SkipConditionalExpr();
   if (Token::IsAssignmentOperator(CurrentToken())) {
     ConsumeToken();
     SkipExpr();
   }
@@ skipping 10 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart