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..16f145a047a88d8db3a38a854822d587f7530139 100644
--- a/lib/compiler/implementation/scanner/parser.dart
+++ b/lib/compiler/implementation/scanner/parser.dart
@@ -9,6 +9,7 @@
 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);
 
@@ -855,16 +856,28 @@ class Parser {
   }
 
   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;
   }
@@ -879,6 +892,9 @@ class Parser {
       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
@@ -946,7 +962,7 @@ 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();