Made parsePrecedenceExpression not take an optional argument.

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 (aka a token stream).
  *
  * The class [Scanner] is used to generate a token stream. See the
  * file scanner.dart.
@@ skipping 1171 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, ASSIGNMENT_PRECEDENCE,
-                                     withoutCascades: false);
+    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, true);
   }
 
   Token parseExpressionWithoutCascade(Token token) {
-    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE,
-                                     withoutCascades: true);
+    return parsePrecedenceExpression(token, ASSIGNMENT_PRECEDENCE, false);
   }
 
   Token parseConditionalExpressionRest(Token token) {
     assert(optional('?', token));
     Token question = token;
     token = parseExpressionWithoutCascade(token.next);
     Token colon = token;
     token = expect(':', token);
     token = parseExpressionWithoutCascade(token);
     listener.handleConditionalExpression(question, colon);
     return token;
   }
 
   Token parsePrecedenceExpression(Token token, int precedence,
-                                  [bool withoutCascades]) {
+                                  bool allowCascades) {
     assert(precedence >= 1);
     assert(precedence <= POSTFIX_PRECEDENCE);
-    token = parseUnaryExpression(token, withoutCascades);
+    token = parseUnaryExpression(token, allowCascades);
     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) {
+          if (!allowCascades) {
             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, withoutCascades);
+          token = parsePrecedenceExpression(token.next, level, allowCascades);
           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, withoutCascades);
+            token = parseUnaryExpression(token.next, allowCascades);
             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 === AS_INFO) {
           token = parseAsOperatorRest(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,
-                                            withoutCascades);
+                                            allowCascades);
           listener.handleBinaryExpression(operator);
         }
         info = token.info;
         tokenLevel = info.precedence;
       }
     }
     return token;
   }
 
   Token parseCascadeExpression(Token token) {
@@ skipping 22 matching lines @@
 
     if (token.info.precedence === ASSIGNMENT_PRECEDENCE) {
       Token assignment = token;
       token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
     listener.endCascade();
     return token;
   }
 
-  Token parseUnaryExpression(Token token, bool withoutCascades) {
+  Token parseUnaryExpression(Token token, bool allowCascades) {
     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,
-                                       withoutCascades);
+                                       allowCascades);
     } else if ((value === '!') ||
                (value === '-') ||
                (value === '~')) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
       token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
-                                        withoutCascades);
+                                        allowCascades);
       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,
-                                        withoutCascades);
+                                        allowCascades);
       listener.handleUnaryPrefixAssignmentExpression(operator);
     } else {
       token = parsePrimary(token);
     }
     return token;
   }
 
   Token parseArgumentOrIndexStar(Token token) {
     while (true) {
       if (optional('[', token)) {
@@ skipping 697 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }