Make sure the "Skip*" functions know about cascades as well.

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 6246 matching lines @@
         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);
+
+    // Assignments after a cascade are part of the cascade. The
+    // assigned expression must not contain cascades.
+    if (Token::IsAssignmentOperator(CurrentToken())) {
+      Token::Kind assignment_op = CurrentToken();
+      const intptr_t assignment_pos = TokenPos();
+      ConsumeToken();
+      AstNode* right_expr = ParseExpr(kAllowConst, kNoCascades);
+      AstNode* left_expr = expr;
+      if (assignment_op != Token::kASSIGN) {
+        // Compound assignment: store inputs with side effects into
+        // temporary 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));
+      }
+      expr = assign_expr;
+    }
     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, kConsumeCascades);
+  AstNode* right_expr = ParseExpr(require_compiletime_const, consume_cascades);
   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,
@@ skipping 203 matching lines @@
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   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,
-                                          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, 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 {
-    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
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
@@ skipping 11 matching lines @@
 AstNode* Parser::ParseStaticFieldAccess(const Class& cls,
                                         const String& field_name,
                                         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();
+    // Make sure an assignment is legal.
     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, 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,
-                                         Class::ZoneHandle(cls.raw()),
-                                         String::ZoneHandle(field_name.raw()));
+      access = new StaticGetterNode(call_pos,
+                                    NULL,
+                                    Class::ZoneHandle(cls.raw()),
+                                    String::ZoneHandle(field_name.raw()));
     } else {
       // Field exists.
       if (field.is_final()) {
         // 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, TokenPos());
+      access = GenerateStaticFieldLookup(field, TokenPos());
     }
-    value = ExpandAssignableOp(call_pos, assignment_op, load_access, 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,
                                      kNoArgumentNames,
                                      Resolver::kIsQualified);
       if (func.IsNull()) {
         // We might be referring to an implicit closure, check to see if
         // there is a function of the same name.
         func = cls.LookupStaticFunction(field_name);
         if (func.IsNull()) {
           // No field or explicit getter function, this is an error.
           ErrorMsg(ident_pos,
                    "unknown static field '%s'", field_name.ToCString());
-          return access;
         }
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
         access = new StaticGetterNode(call_pos,
                                       NULL,
                                       Class::ZoneHandle(cls.raw()),
                                       field_name);
       }
     } else {
-      return GenerateStaticFieldLookup(field, TokenPos());
+      access = GenerateStaticFieldLookup(field, TokenPos());
     }
   }
   return access;
 }
 
 
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
     return node;
   }
@@ skipping 73 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, !is_cascade);
+          selector = CallGetter(ident_pos, left, *ident);
         } else {
           // Static field access.
           selector =
               ParseStaticFieldAccess(cls, *ident, ident_pos, !is_cascade);
         }
       }
     } else if (CurrentToken() == Token::kLBRACK) {
       const intptr_t bracket_pos = TokenPos();
       ConsumeToken();
       left = LoadFieldIfUnresolved(left);
@@ skipping 1865 matching lines @@
         ConsumeToken();  // Handle pseudo-keyword identifiers.
       } else {
         UnexpectedToken();
         UNREACHABLE();
       }
       break;
   }
 }
 
 
-void Parser::SkipPostfixExpr() {
-  SkipPrimary();
+void Parser::SkipSelectors() {
   while (true) {
-    if (CurrentToken() == Token::kPERIOD) {
+    if ((CurrentToken() == Token::kPERIOD) ||
+        (CurrentToken() == Token::kCASCADE)) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
     } else if (CurrentToken() == Token::kLBRACK) {
       ConsumeToken();
       SkipNestedExpr();
       ExpectToken(Token::kRBRACK);
     } else if (CurrentToken() == Token::kLPAREN) {
       SkipActualParameters();
     } else {
       break;
     }
   }
+}
+
+void Parser::SkipPostfixExpr() {
+  SkipPrimary();
+  SkipSelectors();
   if (IsIncrementOperator(CurrentToken())) {
     ConsumeToken();
   }
 }
 
 
 void Parser::SkipUnaryExpr() {
   if (IsPrefixOperator(CurrentToken()) ||
       IsIncrementOperator(CurrentToken())) {
     ConsumeToken();
@@ skipping 20 matching lines @@
     ConsumeToken();
     SkipExpr();
     ExpectToken(Token::kCOLON);
     SkipExpr();
   }
 }
 
 
 void Parser::SkipExpr() {
   SkipConditionalExpr();
+  if (CurrentToken() == Token::kCASCADE) {
+    SkipSelectors();
+  }
   if (Token::IsAssignmentOperator(CurrentToken())) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart