Fix small problems with precedence of cascades.

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 00ccaa2c81acea9ec55bbd237cfd4ee3a4da6b81..9783838cee7b989477886e42f2a06aa7f82068b0 100644
--- a/lib/compiler/implementation/scanner/parser.dart
+++ b/lib/compiler/implementation/scanner/parser.dart
@@ -855,35 +855,45 @@ class Parser {
   }
 
   Token parseExpression(Token token) {
-    return parsePrecedenceExpression(token, CASCADE_PRECEDENCE);
+    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE,
+                                     withoutCascades: false);
+  }
+
+  Token parseExpressionWithoutCascade(Token token) {
+    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE,
+                                     withoutCascades: true);
   }
 
   Token parseConditionalExpressionRest(Token token) {
     assert(optional('?', token));
     Token question = token;
-    token = parseExpression(token.next);
+    token = parseExpressionWithoutCascade(token.next);
     Token colon = token;
     token = expect(':', token);
-    token = parseExpression(token);
+    token = parseExpressionWithoutCascade(token);
     listener.handleConditionalExpression(question, colon);
     return token;
   }
 
-  Token parsePrecedenceExpression(Token token, int precedence) {
+  Token parsePrecedenceExpression(Token token, int precedence,
+                                  [bool withoutCascades]) {

[ahe, 2012/05/01 15:50:50]

No optional parameters please. This code is extremely hot :-)

[ahe, 2012/09/24 16:49:01]

Why was this submitted without addressing my comments?

[Lasse Reichstein Nielsen, 2012/09/24 17:58:09]

A really good question. I vaguely remember actually doing the rename. Don't know
how it got lost again.
Will fix.

     assert(precedence >= 1);
     assert(precedence <= POSTFIX_PRECEDENCE);
-    token = parseUnaryExpression(token);
+    token = parseUnaryExpression(token, withoutCascades);

[ahe, 2012/05/01 15:50:50]

It seems clearer too me if this parameter is named allowCascades. WDYT?

     PrecedenceInfo info = token.info;
     int tokenLevel = info.precedence;
     for (int level = tokenLevel; level >= precedence; --level) {
       while (tokenLevel === level) {
         Token operator = token;
         if (tokenLevel === CASCADE_PRECEDENCE) {
+          if (withoutCascades) {
+            return token;
+          }
           token = parseCascadeExpression(token);
         } else if (tokenLevel === ASSIGNMENT_PRECEDENCE) {
           // Right associative, so we recurse at the same precedence
           // level.
-          token = parsePrecedenceExpression(token.next, level);
+          token = parsePrecedenceExpression(token.next, level, withoutCascades);
           listener.handleAssignmentExpression(operator);
         } else if (tokenLevel === POSTFIX_PRECEDENCE) {
           if (info === PERIOD_INFO) {
@@ -891,7 +901,7 @@ class Parser {
             // precedence level. However, POSTFIX_PRECEDENCE is the
             // highest level, so we just call parseUnaryExpression
             // directly.
-            token = parseUnaryExpression(token.next);
+            token = parseUnaryExpression(token.next, withoutCascades);
             listener.handleBinaryExpression(operator);
           } else if ((info === OPEN_PAREN_INFO) ||
                      (info === OPEN_SQUARE_BRACKET_INFO)) {
@@ -910,7 +920,8 @@ class Parser {
         } else {
           // Left associative, so we recurse at the next higher
           // precedence level.
-          token = parsePrecedenceExpression(token.next, level + 1);
+          token = parsePrecedenceExpression(token.next, level + 1,
+                                            withoutCascades);
           listener.handleBinaryExpression(operator);
         }
         info = token.info;
@@ -946,14 +957,14 @@ class Parser {
 
     if (token.info.precedence === ASSIGNMENT_PRECEDENCE) {
       Token assignment = token;
-      token = parsePrecedenceExpression(token.next, CASCADE_PRECEDENCE + 1);
+      token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
     listener.endCascade();
     return token;
   }
 
-  Token parseUnaryExpression(Token token) {
+  Token parseUnaryExpression(Token token, bool withoutCascades) {
     String value = token.stringValue;
     // Prefix:
     if (value === '+') {
@@ -972,21 +983,24 @@ class Parser {
         }
       }
       listener.recoverableError("Unexpected token '+'", token: token);
-      return parsePrecedenceExpression(next, POSTFIX_PRECEDENCE);
+      return parsePrecedenceExpression(next, POSTFIX_PRECEDENCE,
+                                       withoutCascades);
     } else if ((value === '!') ||
                (value === '-') ||
                (value === '~')) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
-      token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE);
+      token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
+                                        withoutCascades);
       listener.handleUnaryPrefixExpression(operator);
     } else if ((value === '++') || value === '--') {
       // TODO(ahe): Validate this is used correctly.
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
-      token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE);
+      token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
+                                        withoutCascades);
       listener.handleUnaryPrefixAssignmentExpression(operator);
     } else {
       token = parsePrimary(token);