Fix small problems with precedence of cascades.

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 837 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, 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) {
             // Left associative, so we recurse at the next higher
             // 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)) {
             token = parseArgumentOrIndexStar(token);
           } else if ((info === PLUS_PLUS_INFO) ||
                      (info === MINUS_MINUS_INFO)) {
             listener.handleUnaryPostfixAssignmentExpression(token);
             token = token.next;
           } else {
             token = listener.unexpected(token);
           }
         } else if (info === IS_INFO) {
           token = parseIsOperatorRest(token);
         } else if (info === QUESTION_INFO) {
           token = parseConditionalExpressionRest(token);
         } 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;
         tokenLevel = info.precedence;
       }
     }
     return token;
   }
 
   Token parseCascadeExpression(Token token) {
@@ skipping 15 matching lines @@
       if (optional('.', token)) {
         Token period = token;
         token = parseSend(token.next);
         listener.handleBinaryExpression(period);
       }
       token = parseArgumentOrIndexStar(token);
     } while (mark !== token);
 
     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 === '+') {
       // 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) {
           listener.handleLiteralInt(token);
           return next.next;
         }
         if (next.kind === DOUBLE_TOKEN) {
           listener.handleLiteralDouble(token);
           return next.next;
         }
       }
       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);
     }
     return token;
   }
 
   Token parseArgumentOrIndexStar(Token token) {
     while (true) {
       if (optional('[', token)) {
@@ skipping 619 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }