Implement cascaded calls.

lib/compiler/implementation/scanner/parser.dart

Index: lib/compiler/implementation/scanner/parser.dart
diff --git a/lib/compiler/implementation/scanner/parser.dart b/lib/compiler/implementation/scanner/parser.dart
index aad8ee44c54f71f6d39cf3940c7f7cb29830128a..08dd46e5e740f0d69d878b73e94d200983198a14 100644
--- a/lib/compiler/implementation/scanner/parser.dart
+++ b/lib/compiler/implementation/scanner/parser.dart
@@ -236,7 +236,6 @@ class Parser {
     return token.next;
   }
 
-
   Token parseStringPart(Token token) {
     if (token.kind === STRING_TOKEN) {
       listener.handleStringPart(token);
@@ -856,7 +855,7 @@ class Parser {
   }
 
   Token parseExpression(Token token) {
-    return parsePrecedenceExpression(token, 2);
+    return parsePrecedenceExpression(token, SEQUENCE_PRECEDENCE);
   }
 
   Token parseConditionalExpressionRest(Token token) {
@@ -871,7 +870,7 @@ class Parser {
   }
 
   Token parsePrecedenceExpression(Token token, int precedence) {
-    assert(precedence >= 2);
+    assert(precedence >= 1);
     assert(precedence <= POSTFIX_PRECEDENCE);
     token = parseUnaryExpression(token);
     PrecedenceInfo info = token.info;
@@ -879,7 +878,9 @@ class Parser {
     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);
@@ -919,6 +920,37 @@ class Parser {
     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: