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, SEQUENCE_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 === SEQUENCE_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) {
+    Token next = expect('..', token);

[ahe, 2012/04/16 08:55:23]

I normally use:

  assert(optional('..', token))

when the token is already checked before calling.

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+    listener.beginCascade(token);

[ahe, 2012/04/16 08:55:23]

In general, it is best to call the begin method before calling expect. This way
the listener knows what is going on and has a better chance at recovering from
the error. However, in this case, it is not necessary to call expect.

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+    if (optional('[', next)) {
+      next = parseArgumentOrIndexStar(next);

[ahe, 2012/04/16 08:55:23]

Normally, I use this pattern:

token = parse...

This is deliberate, as I assume token gets assigned a register. If the incoming
token is needed later, I give it a name. For example, see
parseConditionalExpressionRest above.

Ignoring the register guesswork, I'd like the code to be consistent. This means
that the variable named "token" always holds the next token.

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+    } else if (next.kind == IDENTIFIER_TOKEN) {

[ahe, 2012/04/16 08:55:23]

What if it is a pseudo keyword? Perhaps you should use "isIdentifier(next)".

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+      next = parseSend(next);
+      listener.handleBinaryExpression(token);

[ahe, 2012/04/16 08:55:23]

For example, this sequence is confusing (to me) because token doesn't mean what
it does in other parts of the parser.

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Changed to have a more readable name for token.

+    } else {
+      return listener.unexpected(next);
+    }
+    Token mark;
+    do {
+      mark = next;
+      if (optional('.', next)) {
+        Token dot = next;

[ahe, 2012/04/16 08:55:23]

I have used the word "period" instead of "dot" in other places.

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+        next = parseSend(dot.next);
+        listener.handleBinaryExpression(dot);
+      }
+      next = parseArgumentOrIndexStar(next);
+    } while (mark != next);

[ahe, 2012/04/16 08:55:23]

!==

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+
+    if (next.info.precedence == ASSIGNMENT_PRECEDENCE) {

[ahe, 2012/04/16 08:55:23]

===

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

Done.

+      Token assignment = next;
+      next = parsePrecedenceExpression(next.next, SEQUENCE_PRECEDENCE + 1);

[ahe, 2012/04/16 08:55:23]

Question to make sure I understand what is going on here: I guess this means
that you cannot write:

x..y = a = b;

Perhaps you should test that?

[Lasse Reichstein Nielsen, 2012/04/16 12:41:38]

You should be able to write that. It would parse as
 x..y = (a = b)
(which is fine, since assignment is right-associative).

This means that you cannot have a cascade om the expression after the
assignment-operator.
SEQUENCE is just the wrong name, I'll change it to CASCADE.

+      listener.handleAssignmentExpression(assignment);
+    }
+    listener.endCascade();
+    return next;
+  }
+
   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);
   }
 }