Implement cascaded calls.

lib/compiler/implementation/scanner/parser.dart

 // 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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list.
  */
 class Parser {
   final Listener listener;
@@ skipping 218 matching lines @@
         token = parseType(token.next);
         ++interfacesCount;
       } while (optional(',', token));
     }
     token = parseClassBody(token);
     listener.endClassDeclaration(interfacesCount, begin, extendsKeyword,
                                  implementsKeyword, token);
     return token.next;
   }
 
-
   Token parseStringPart(Token token) {
     if (token.kind === STRING_TOKEN) {
       listener.handleStringPart(token);
       return token.next;
     } else {
       return listener.expected('string', token);
     }
   }
 
   Token parseIdentifier(Token token) {
@@ skipping 599 matching lines @@
   }
 
   Token parseExpressionStatement(Token token) {
     listener.beginExpressionStatement(token);
     token = parseExpression(token);
     listener.endExpressionStatement(token);
     return expectSemicolon(token);
   }
 
   Token parseExpression(Token token) {
-    return parsePrecedenceExpression(token, 2);
+    return parsePrecedenceExpression(token, CASCADE_PRECEDENCE);
   }
 
   Token parseConditionalExpressionRest(Token token) {
     assert(optional('?', token));
     Token question = token;
     token = parseExpression(token.next);
     Token colon = token;
     token = expect(':', token);
     token = parseExpression(token);
     listener.handleConditionalExpression(question, colon);
     return token;
   }
 
   Token parsePrecedenceExpression(Token token, int precedence) {
-    assert(precedence >= 2);
+    assert(precedence >= 1);
     assert(precedence <= POSTFIX_PRECEDENCE);
     token = parseUnaryExpression(token);
     PrecedenceInfo info = token.info;
     int tokenLevel = info.precedence;
     for (int level = tokenLevel; level >= precedence; --level) {
       while (tokenLevel === level) {
         Token operator = token;
-        if (tokenLevel === ASSIGNMENT_PRECEDENCE) {
+        if (tokenLevel === CASCADE_PRECEDENCE) {
+          token = parseCascadeExpression(token);
+        } else if (tokenLevel === ASSIGNMENT_PRECEDENCE) {
           // Right associative, so we recurse at the same precedence
           // level.
           token = parsePrecedenceExpression(token.next, level);
           listener.handleAssignmentExpression(operator);
         } else if (tokenLevel === POSTFIX_PRECEDENCE) {
           if (info === PERIOD_INFO) {
             // Left associative, so we recurse at the next higher
             // precedence level. However, POSTFIX_PRECEDENCE is the
             // highest level, so we just call parseUnaryExpression
             // directly.
@@ skipping 19 matching lines @@
           token = parsePrecedenceExpression(token.next, level + 1);
           listener.handleBinaryExpression(operator);
         }
         info = token.info;
         tokenLevel = info.precedence;
       }
     }
     return token;
   }
 
+  Token parseCascadeExpression(Token token) {
+    listener.beginCascade(token);
+    assert(optional('..', token));
+    Token cascadeOperator = token;
+    if (optional('[', token)) {
+      token = parseArgumentOrIndexStar(token);
+    } else if (isIdentifier(token)) {
+      token = parseSend(token);
+      listener.handleBinaryExpression(cascadeOperator);
+    } else {
+      return listener.unexpected(token);
+    }
+    Token mark;
+    do {
+      mark = token;
+      if (optional('.', token)) {
+        Token period = token;
+        token = parseSend(period.token);
+        listener.handleBinaryExpression(period);
+      }
+      token = parseArgumentOrIndexStar(token);
+    } while (mark !== token);
+
+    if (token.info.precedence === ASSIGNMENT_PRECEDENCE) {
+      Token assignment = token;
+      token = parsePrecedenceExpression(token.token, CASCADE_PRECEDENCE + 1);
+      listener.handleAssignmentExpression(assignment);
+    }
+    listener.endCascade();
+    return token;
+  }
+
   Token parseUnaryExpression(Token token) {
     String value = token.stringValue;
     // Prefix:
     if (value === '+') {
       // Dart only allows "prefix plus" as an initial part of a
       // decimal literal. We scan it as a separate token and let
       // the parser listener combine it with the digits.
       Token next = token.next;
       if (next.charOffset === token.charOffset + 1) {
         if (next.kind === INT_TOKEN) {
@@ skipping 651 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }