Implement cascade operator in VM

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 757 matching lines @@
 
   // Static const fields must have an initializer.
   ExpectToken(Token::kASSIGN);
 
   // We don't want to use ParseConstExpr() here because we don't want
   // the constant folding code to create, compile and execute a code
   // fragment to evaluate the expression. Instead, we just make sure
   // the static const field initializer is a constant expression and
   // leave the evaluation to the getter function.
   const intptr_t expr_pos = TokenPos();
-  AstNode* expr = ParseExpr(kAllowConst);
+  AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
   if (field.is_const()) {
     // This getter will only be called once at compile time.
     if (expr->EvalConstExpr() == NULL) {
       ErrorMsg(expr_pos, "initializer must be a compile time constant");
     }
     ReturnNode* return_node = new ReturnNode(TokenPos(), expr);
     current_block_->statements->Add(return_node);
   } else {
     // This getter may be called each time the static field is accessed.
     // The following generated code lazily initializes the field:
@@ skipping 540 matching lines @@
 }
 
 
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const intptr_t operator_pos = TokenPos();
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
-    AstNode* index_expr = ParseExpr(kAllowConst);
+    AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
 
     if (Token::IsAssignmentOperator(CurrentToken()) &&
         (CurrentToken() != Token::kASSIGN)) {
       // Compound assignment. Ensure side effects in index expression
       // only execute once. If the index is not a local variable or an
       // literal, evaluate and save in a temporary local.
       if (!IsSimpleLocalOrLiteralNode(index_expr)) {
         LocalVariable* temp =
             CreateTempConstVariable(operator_pos, index_expr->id(), "lix");
@@ skipping 21 matching lines @@
     if (is_no_such_method) {
       index_op_arguments = BuildNoSuchMethodArguments(index_operator_name,
                                                       *index_op_arguments);
     }
     super_op = new StaticCallNode(
         operator_pos, index_operator, index_op_arguments);
 
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
       ConsumeToken();
-      AstNode* value = ParseExpr(kAllowConst);
+      AstNode* value = ParseExpr(kAllowConst, kConsumeCascades);
 
       value = ExpandAssignableOp(operator_pos, assignment_op, super_op, value);
 
       // Resolve the []= operator function in the superclass.
       const String& assign_index_operator_name = String::ZoneHandle(
           Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
       bool is_no_such_method = false;
       const Function& assign_index_operator = Function::ZoneHandle(
           GetSuperFunction(operator_pos,
                            assign_index_operator_name,
@@ skipping 107 matching lines @@
     if (super_setter.IsNull()) {
       ErrorMsg(field_pos,
                "field '%s' not assignable in superclass",
                field_name.ToCString());
     }
     // All dynamic setters take two arguments and no named arguments.
     ASSERT(super_setter.AreValidArgumentCounts(2, 0, NULL));
 
     Token::Kind assignment_op = CurrentToken();
     ConsumeToken();
-    AstNode* value = ParseExpr(kAllowConst);
+    AstNode* value = ParseExpr(kAllowConst, kConsumeCascades);
     value = ExpandAssignableOp(field_pos, assignment_op, super_field, value);
 
     ArgumentListNode* setter_arguments = new ArgumentListNode(field_pos);
     setter_arguments->Add(implicit_argument);
     setter_arguments->Add(value);
     super_field = new StaticCallNode(field_pos, super_setter, setter_arguments);
   }
   return super_field;
 }
 
@@ skipping 651 matching lines @@
   }
 
   OpenBlock();  // Open a nested scope for the outermost function block.
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     const intptr_t expr_pos = TokenPos();
-    AstNode* expr = ParseExpr(kAllowConst);
+    AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
   } else {
     UnexpectedToken();
   }
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
@@ skipping 1899 matching lines @@
   LocalVariable* variable =
       new LocalVariable(ident_pos, *CurrentLiteral(), type);
   ASSERT(current_block_ != NULL);
   ASSERT(current_block_->scope != NULL);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
-    AstNode* expr = ParseExpr(kAllowConst);
+    AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     initialization = new StoreLocalNode(assign_pos, *variable, expr);
   } else if (is_final) {
     ErrorMsg(ident_pos, "missing initialization of 'final' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
     initialization = new StoreLocalNode(ident_pos, *variable, null_expr);
   }
   // Add variable to cope after parsing the initalizer expression.
   // The expression must not be able to refer to the variable.
@@ skipping 553 matching lines @@
   ASSERT(CurrentToken() == Token::kIF);
   const intptr_t if_pos = TokenPos();
   SourceLabel* label = NULL;
   if (label_name != NULL) {
     label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(label);
   }
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
-  AstNode* cond_expr = ParseExpr(kAllowConst);
+  AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body = false;
   SequenceNode* true_branch = ParseNestedStatement(parsing_loop_body, NULL);
   SequenceNode* false_branch = NULL;
   if (CurrentToken() == Token::kELSE) {
     ConsumeToken();
     false_branch = ParseNestedStatement(parsing_loop_body, NULL);
   }
   AstNode* if_node = new IfNode(if_pos, cond_expr, true_branch, false_branch);
   if (label != NULL) {
@@ skipping 13 matching lines @@
   const intptr_t case_pos = TokenPos();
   // The case expressions node sequence does not own the enclosing scope.
   SequenceNode* case_expressions = new SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ErrorMsg("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
       const intptr_t expr_pos = TokenPos();
-      AstNode* expr = ParseExpr(kAllowConst);
+      AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       AstNode* switch_expr_load = new LoadLocalNode(case_pos,
                                                     *switch_expr_value);
       AstNode* case_comparison = new ComparisonNode(expr_pos,
                                                     Token::kEQ,
                                                     expr,
                                                     switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
       if (default_seen) {
         ErrorMsg("only one default clause is allowed");
@@ skipping 55 matching lines @@
   ConsumeToken();
   const bool parens_are_mandatory = false;
   bool paren_found = false;
   if (CurrentToken() == Token::kLPAREN) {
     paren_found = true;
     ConsumeToken();
   } else if (parens_are_mandatory) {
     ErrorMsg("'(' expected");
   }
   const intptr_t expr_pos = TokenPos();
-  AstNode* switch_expr = ParseExpr(kAllowConst);
+  AstNode* switch_expr = ParseExpr(kAllowConst, kConsumeCascades);
   if (paren_found) {
     ExpectToken(Token::kRPAREN);
   }
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
@@ skipping 62 matching lines @@
 }
 
 
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
   const intptr_t while_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
-  AstNode* cond_expr = ParseExpr(kAllowConst);
+  AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
   return new WhileNode(while_pos, label, cond_expr, while_body);
 }
 
 
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
   const intptr_t do_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body =  true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
-  AstNode* cond_expr = ParseExpr(kAllowConst);
+  AstNode* cond_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
@@ skipping 10 matching lines @@
                                 ClassFinalizer::kIgnore));
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
-  AstNode* collection_expr = ParseExpr(kAllowConst);
+  AstNode* collection_expr = ParseExpr(kAllowConst, kConsumeCascades);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   const String& iterator_name =
       String::ZoneHandle(Symbols::New(":for-in-iter"));
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
@@ skipping 89 matching lines @@
   // The label is added to the implicit scope that also contains
   // the loop variable declarations.
   current_block_->scope->AddLabel(label);
   AstNode* initializer = NULL;
   const intptr_t init_pos = TokenPos();
   LocalScope* init_scope = current_block_->scope;
   if (CurrentToken() != Token::kSEMICOLON) {
     if (IsVariableDeclaration()) {
       initializer = ParseVariableDeclarationList();
     } else {
-      initializer = ParseExpr(kAllowConst);
+      initializer = ParseExpr(kAllowConst, kConsumeCascades);
     }
   }
   ExpectSemicolon();
   AstNode* condition = NULL;
   if (CurrentToken() != Token::kSEMICOLON) {
-    condition = ParseExpr(kAllowConst);
+    condition = ParseExpr(kAllowConst, kConsumeCascades);
   }
   ExpectSemicolon();
   AstNode* increment = NULL;
   const intptr_t incr_pos = TokenPos();
   LocalScope* incr_scope = current_block_->scope;
   if (CurrentToken() != Token::kRPAREN) {
     increment = ParseExprList();
   }
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body =  true;
@@ skipping 77 matching lines @@
 AstNode* Parser::ParseAssertStatement() {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const intptr_t condition_pos = TokenPos();
   if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
-  AstNode* condition = ParseExpr(kAllowConst);
+  AstNode* condition = ParseExpr(kAllowConst, kConsumeCascades);
   const intptr_t condition_end = TokenPos();
   ExpectToken(Token::kRPAREN);
   condition = InsertClosureCallNodes(condition);
   condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new IfNode(condition_pos,
                     condition,
                     NodeAsSequenceNode(condition_pos, assert_throw, NULL),
                     NULL);
 }
@@ skipping 453 matching lines @@
   } else if (CurrentToken() == Token::kTRY) {
     statement = ParseTryStatement(label_name);
   } else if (CurrentToken() == Token::kRETURN) {
     const intptr_t return_pos = TokenPos();
     ConsumeToken();
     if (CurrentToken() != Token::kSEMICOLON) {
       if (current_function().IsConstructor() &&
           (current_block_->scope->function_level() == 0)) {
         ErrorMsg(return_pos, "return of a value not allowed in constructors");
       }
-      AstNode* expr = ParseExpr(kAllowConst);
+      AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       statement = new ReturnNode(statement_pos, expr);
     } else {
       statement = new ReturnNode(statement_pos);
     }
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kIF) {
     statement = ParseIfStatement(label_name);
   } else if ((CurrentToken() == Token::kASSERT) &&
              !IsDefinedInLexicalScope(*CurrentLiteral())) {
@@ skipping 26 matching lines @@
     statement = ParseJump(label_name);
     AddNodeForFinallyInlining(statement);
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Empty statement, nothing to do.
     ConsumeToken();
   } else if (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
     AstNode* expr = NULL;
     if (CurrentToken() != Token::kSEMICOLON) {
-      expr = ParseExpr(kAllowConst);
+      expr = ParseExpr(kAllowConst, kConsumeCascades);
       ExpectSemicolon();
       statement = new ThrowNode(statement_pos, expr, NULL);
     } else {  // No exception object seen so must be a rethrow.
       // Check if it is ok to do a rethrow.
       SourceLabel* label = current_block_->scope->LookupInnermostCatchLabel();
       if (label == NULL ||
           label->FunctionLevel() != current_block_->scope->function_level()) {
         ErrorMsg("rethrow of an exception is not valid here");
       }
       ASSERT(label->owner() != NULL);
       LocalScope* scope = label->owner()->parent();
       ASSERT(scope != NULL);
       LocalVariable* excp_var = scope->LocalLookupVariable(
           String::ZoneHandle(Symbols::New(":exception_var")));
       ASSERT(excp_var != NULL);
       LocalVariable* trace_var = scope->LocalLookupVariable(
           String::ZoneHandle(Symbols::New(":stacktrace_var")));
       ASSERT(trace_var != NULL);
       statement = new ThrowNode(statement_pos,
                                 new LoadLocalNode(statement_pos, *excp_var),
                                 new LoadLocalNode(statement_pos, *trace_var));
     }
   } else {
-    statement = ParseExpr(kAllowConst);
+    statement = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
 RawError* Parser::FormatErrorWithAppend(const Error& prev_error,
                                         const Script& script,
                                         intptr_t token_pos,
                                         const char* message_header,
@@ skipping 350 matching lines @@
       || (expr->IsLoadLocalNode() && !expr->AsLoadLocalNode()->HasPseudo())
       || expr->IsLoadStaticFieldNode()
       || expr->IsStaticGetterNode()
       || expr->IsInstanceGetterNode()
       || expr->IsLoadIndexedNode();
 }
 
 
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
-  AstNode* expressions = ParseExpr(kAllowConst);
+  AstNode* expressions = ParseExpr(kAllowConst, kConsumeCascades);
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
     SequenceNode* list = new SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
-      AstNode* expr = ParseExpr(kAllowConst);
+      AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
 const LocalVariable& Parser::GetIncrementTempLocal() {
   if (expression_temp_ == NULL) {
@@ skipping 172 matching lines @@
 AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if ((result != NULL) &&
       (result->IsStoreIndexedNode() || result->IsInstanceSetterNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
-AstNode* Parser::ParseExpr(bool require_compiletime_const) {
+AstNode* Parser::ParseCascades(AstNode* expr) {
+  intptr_t cascade_pos = TokenPos();
+  LocalVariable* cascade_receiver_var =
+      CreateTempConstVariable(cascade_pos, expr->id(), "casc");
+  StoreLocalNode* save_cascade =
+      new StoreLocalNode(cascade_pos, *cascade_receiver_var, expr);
+  current_block_->statements->Add(save_cascade);
+  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 {
+      ErrorMsg("identifier or [ expected after ..");
+    }
+    expr = ParseSelectors(load_cascade_receiver, true);
+    current_block_->statements->Add(expr);
+  }
+  // Result of the cascade is the receiver.
+  return 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();
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
+    if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
+      return ParseCascades(expr);
+    }
     if (require_compiletime_const) {
       expr = FoldConstExpr(expr_pos, expr);
     }
     return expr;
   }
   // Assignment expressions.
   Token::Kind assignment_op = CurrentToken();
   const intptr_t assignment_pos = TokenPos();
   ConsumeToken();
   const intptr_t right_expr_pos = TokenPos();
   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* right_expr = ParseExpr(require_compiletime_const, kConsumeCascades);
   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 = 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() {
   TRACE_PARSER("ParseConstExpr");
-  AstNode* expr = ParseExpr(kRequireConst);
+  AstNode* expr = ParseExpr(kRequireConst, kNoCascades);
   ASSERT(expr->IsLiteralNode());
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
   if (CurrentToken() == Token::kCONDITIONAL) {
     EnsureExpressionTemp();
     ConsumeToken();
-    AstNode* expr1 = ParseExpr(kAllowConst);
+    AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
     ExpectToken(Token::kCOLON);
-    AstNode* expr2 = ParseExpr(kAllowConst);
+    AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
     expr = new ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const intptr_t op_pos = TokenPos();
@@ skipping 67 matching lines @@
           if (CurrentLiteral()->Equals(arg_name)) {
             ErrorMsg("duplicate named argument");
           }
         }
         names.Add(*CurrentLiteral());
         ConsumeToken();  // ident.
         ConsumeToken();  // colon.
       } else if (named_argument_seen) {
         ErrorMsg("named argument expected");
       }
-      arguments->Add(ParseExpr(require_const));
+      arguments->Add(ParseExpr(require_const, kConsumeCascades));
     } while (CurrentToken() == Token::kCOMMA);
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
     arguments->set_names(Array::Handle(Array::MakeArray(names)));
   }
   return arguments;
@@ skipping 81 matching lines @@
   TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   EnsureExpressionTemp();
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new ClosureCallNode(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceFieldAccess(AstNode* receiver,
-                                          const String& field_name) {
+                                          const String& field_name,
+                                          bool consume_cascades) {
   TRACE_PARSER("ParseInstanceFieldAccess");
   AstNode* access = NULL;
   const intptr_t call_pos = TokenPos();
   if (Token::IsAssignmentOperator(CurrentToken())) {
     Token::Kind assignment_op = CurrentToken();
     ConsumeToken();
-    AstNode* value = ParseExpr(kAllowConst);
+    AstNode* value = ParseExpr(kAllowConst, consume_cascades);
     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 = CreateAssignmentNode(left_load_access, value);
   } else {
@@ skipping 19 matching lines @@
     ASSERT(field.value() != Object::transition_sentinel());
     return new LiteralNode(ident_pos, Instance::ZoneHandle(field.value()));
   }
   // Access the field directly.
   return new LoadStaticFieldNode(ident_pos, Field::ZoneHandle(field.raw()));
 }
 
 
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
-                                        intptr_t ident_pos) {
+                                        intptr_t ident_pos,
+                                        bool consume_cascades) {
   TRACE_PARSER("ParseStaticFieldAccess");
   AstNode* access = NULL;
   const intptr_t call_pos = TokenPos();
   const Field& field = Field::ZoneHandle(cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle();
   if (Token::IsAssignmentOperator(CurrentToken())) {
     Token::Kind assignment_op = CurrentToken();
     if (field.IsNull()) {
       // No field, check if we have an explicit setter function.
       const String& setter_name =
           String::ZoneHandle(Field::SetterName(field_name));
       const int kNumArguments = 1;  // value.
       const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      setter_name,
                                      kNumArguments,
                                      kNoArgumentNames,
                                      Resolver::kIsQualified);
       if (func.IsNull()) {
         // No field or explicit setter function, this is an error.
         ErrorMsg(ident_pos, "unknown static field '%s'",
                  field_name.ToCString());
         return access;
       }
     }
     ConsumeToken();
-    AstNode* value = ParseExpr(kAllowConst);
+    AstNode* value = ParseExpr(kAllowConst, consume_cascades);
     AstNode* load_access = NULL;
     if (field.IsNull()) {
       // No field found, we must have at least a setter function defined.
       ASSERT(!func.IsNull());
       // Explicit setter function for the field found, field does not exist.
       // Create a getter node first in case it is needed. If getter node
       // is used as part of, e.g., "+=", and the explicit getter does not
       // exist, and error will be reported by the code generator.
       load_access = new StaticGetterNode(call_pos,
                                          NULL,
@@ skipping 92 matching lines @@
                "cannot access instance method '%s' from static method",
                funcname.ToCString());
     }
     AstNode* receiver = LoadReceiver(primary->token_pos());
     closure = CallGetter(primary->token_pos(), receiver, funcname);
   }
   return closure;
 }
 
 
-AstNode* Parser::ParsePostfixExpr() {
-  TRACE_PARSER("ParsePostfixExpr");
-  const intptr_t postfix_expr_pos = TokenPos();
-  AstNode* postfix_expr = ParsePrimary();
+AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
+  AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
-    AstNode* left = postfix_expr;
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       if (left->IsPrimaryNode()) {
         if (left->AsPrimaryNode()->primary().IsFunction()) {
           left = LoadClosure(left->AsPrimaryNode());
         } else {
           left = LoadFieldIfUnresolved(left);
         }
       }
       const intptr_t ident_pos = TokenPos();
@@ skipping 15 matching lines @@
         if (left->IsPrimaryNode()) {
           PrimaryNode* primary_node = left->AsPrimaryNode();
           if (primary_node->primary().IsClass()) {
             // If the primary node referred to a class we are loading a
             // qualified static field.
             cls ^= primary_node->primary().raw();
           }
         }
         if (cls.IsNull()) {
           // Instance field access.
-          selector = ParseInstanceFieldAccess(left, *ident);
+          selector = ParseInstanceFieldAccess(left, *ident, !is_cascade);
         } else {
           // Static field access.
-          selector = ParseStaticFieldAccess(cls, *ident, ident_pos);
+          selector =
+              ParseStaticFieldAccess(cls, *ident, ident_pos, !is_cascade);
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
       const intptr_t bracket_pos = TokenPos();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
       const bool saved_mode = SetAllowFunctionLiterals(true);
-      AstNode* index = ParseExpr(kAllowConst);
+      AstNode* index = ParseExpr(kAllowConst, kConsumeCascades);
       SetAllowFunctionLiterals(saved_mode);
       ExpectToken(Token::kRBRACK);
       AstNode* array = left;
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
           array = LoadClosure(primary);
         } else if (primary->primary().IsClass()) {
           ErrorMsg(bracket_pos, "cannot apply index operator to class");
         } else {
@@ skipping 39 matching lines @@
                    "must use 'new' or 'const' to construct new instance");
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       } else {
         // Left is not a primary node; this must be a closure call.
         AstNode* closure = left;
         selector = ParseClosureCall(closure);
       }
     } else {
-      // No (more) selector to parse.
+      // No (more) selectors to parse.
       left = LoadFieldIfUnresolved(left);
       if (left->IsPrimaryNode()) {
         PrimaryNode* primary = left->AsPrimaryNode();
         if (primary->primary().IsFunction()) {
           // Treat as implicit closure.
           left = LoadClosure(primary);
         } else if (left->AsPrimaryNode()->primary().IsClass()) {
           Class& cls = Class::CheckedHandle(
               left->AsPrimaryNode()->primary().raw());
           String& cls_name = String::Handle(cls.Name());
           ErrorMsg(left->token_pos(),
                    "illegal use of class name '%s'",
                    cls_name.ToCString());
         } else {
           UNREACHABLE();  // Internal parser error.
         }
       }
-      postfix_expr = left;
       // Done parsing selectors.
-      break;
+      return left;
     }
     ASSERT(selector != NULL);
-    postfix_expr = selector;
+    left = selector;
   }
+}
+
+
+AstNode* Parser::ParsePostfixExpr() {
+  TRACE_PARSER("ParsePostfixExpr");
+  const intptr_t postfix_expr_pos = TokenPos();
+  AstNode* postfix_expr = ParsePrimary();
+  postfix_expr = ParseSelectors(postfix_expr, false);
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
     if (!IsAssignableExpr(postfix_expr)) {
       ErrorMsg("expression is not assignable");
     }
     ConsumeToken();
     // Not prefix.
     AstNode* left_expr = PrepareCompoundAssignmentNodes(&postfix_expr);
     const LocalVariable& temp = GetIncrementTempLocal();
@@ skipping 692 matching lines @@
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   ArrayNode* list = new ArrayNode(TokenPos(), type_arguments);
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const String& dst_name = String::ZoneHandle(
         Symbols::New("list literal element"));
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
-      AstNode* element = ParseExpr(is_const);
+      AstNode* element = ParseExpr(is_const, kConsumeCascades);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new AssignableNode(element_pos,
                                      element,
                                      element_type,
                                      dst_name);
       }
       list->AddElement(element);
       if (CurrentToken() == Token::kCOMMA) {
@@ skipping 174 matching lines @@
       key = ParseStringLiteral();
     }
     if (key == NULL) {
       ErrorMsg("map entry key must be string literal");
     } else if (is_const && !key->IsLiteralNode()) {
       ErrorMsg("map entry key must be compile time constant string");
     }
     ExpectToken(Token::kCOLON);
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t value_pos = TokenPos();
-    AstNode* value = ParseExpr(is_const);
+    AstNode* value = ParseExpr(is_const, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     if (FLAG_enable_type_checks &&
         !is_const &&
         !value_type.IsDynamicType()) {
       value = new AssignableNode(value_pos,
                                  value,
                                  value_type,
                                  dst_name);
     }
     AddKeyValuePair(kv_pairs, is_const, key, value);
@@ skipping 438 matching lines @@
     while ((CurrentToken() == Token::kINTERPOL_VAR) ||
         (CurrentToken() == Token::kINTERPOL_START)) {
       AstNode* expr = NULL;
       const intptr_t expr_pos = TokenPos();
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         expr = ResolveIdent(TokenPos(), *CurrentLiteral(), true);
         ConsumeToken();
       } else {
         ASSERT(CurrentToken() == Token::kINTERPOL_START);
         ConsumeToken();
-        expr = ParseExpr(kAllowConst);
+        expr = ParseExpr(kAllowConst, kConsumeCascades);
         ExpectToken(Token::kINTERPOL_END);
       }
       // Check if this interpolated string is still considered a compile time
       // constant. If it is we need to evaluate if the current string part is
       // a constant or not.
       if (is_compiletime_const) {
         const Object* const_expr = expr->EvalConstExpr();
         if (const_expr != NULL) {
           // Change expr into a literal.
           expr = new LiteralNode(expr_pos, EvaluateConstExpr(expr));
@@ skipping 137 matching lines @@
     ConsumeToken();
   } else if (CurrentToken() == Token::kFALSE) {
     primary = new LiteralNode(TokenPos(), Bool::ZoneHandle(Bool::False()));
     ConsumeToken();
   } else if (CurrentToken() == Token::kNULL) {
     primary = new LiteralNode(TokenPos(), Instance::ZoneHandle());
     ConsumeToken();
   } else if (CurrentToken() == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
-    primary = ParseExpr(kAllowConst);
+    primary = ParseExpr(kAllowConst, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
   } else if (CurrentToken() == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
     primary = new LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (CurrentToken() == Token::kSTRING) {
@@ skipping 317 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart