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;
   bool mayParseFunctionExpressions = true;
+  bool mayParseCascades = true;

[ahe, 2012/04/26 14:33:30]

Does this need to be a global flag?

[Lasse Reichstein Nielsen, 2012/04/27 07:08:31]

Actually not. Passing it to just parsePrecedenceExpression and
parseUnaryExpression is enough. I'll change to doing that.

 
   Parser(Listener this.listener);
 
   void parseUnit(Token token) {
     while (token.kind !== EOF_TOKEN) {
       token = parseTopLevelDeclaration(token);
     }
   }
 
   Token parseTopLevelDeclaration(Token token) {
@@ skipping 826 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);
+    bool couldParseCascades = mayParseCascades;
+    mayParseCascades = true;
+    Token result = parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE);
+    mayParseCascades = couldParseCascades;
+    return result;
+  }
+
+  Token parseExpressionWithoutCascade(Token token) {
+    bool couldParseCascades = mayParseCascades;
+    mayParseCascades = false;
+    Token result = parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE);
+    mayParseCascades = couldParseCascades;
+    return result;
   }
 
   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) {
     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 === CASCADE_PRECEDENCE) {
+          if (!mayParseCascades) {

[Lasse Reichstein Nielsen, 2012/04/27 07:08:31]

Another alternative here is to start the outer for-loop with:
  if (level == CASCADE_PRECEDENCE && !mayParseCascades) continue;
It's probably slower than the current approach.

+            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);
           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
@@ skipping 47 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) {
     String value = token.stringValue;
     // Prefix:
     if (value === '+') {
@@ skipping 659 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }