Update dart2js parser to disallow repeated comparisons and prefix +.

sdk/lib/_internal/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.
 
 part of scanner;
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
@@ skipping 1563 matching lines @@
           token = parseConditionalExpressionRest(token);
         } else {
           // Left associative, so we recurse at the next higher
           // precedence level.
           token = parsePrecedenceExpression(token.next, level + 1,
                                             allowCascades);
           listener.handleBinaryExpression(operator);
         }
         info = token.info;
         tokenLevel = info.precedence;
+        if (level == EQUALITY_PRECEDENCE || level == RELATIONAL_PRECEDENCE) {
+          // We don't allow (a == b == c) or (a < b < c).
+          // Continue the outer loop if we have matched one equality or
+          // relational operator.
+          break;
+        }
       }
     }
     return token;
   }
 
   Token parseCascadeExpression(Token token) {
     listener.beginCascade(token);
     assert(optional('..', token));
     Token cascadeOperator = token;
     token = token.next;
@@ skipping 21 matching lines @@
       token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
     listener.endCascade();
     return token;
   }
 
   Token parseUnaryExpression(Token token, bool allowCascades) {
     String value = token.stringValue;
     // Prefix:
-    if (identical(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 (identical(next.charOffset, token.charOffset + 1)) {
-        if (identical(next.kind, INT_TOKEN)) {
-          listener.handleLiteralInt(token);
-          return next.next;
-        }
-        if (identical(next.kind, DOUBLE_TOKEN)) {
-          listener.handleLiteralDouble(token);
-          return next.next;
-        }
-      }
-      listener.recoverableError("Unexpected token '+'", token: token);
-      return parsePrecedenceExpression(next, POSTFIX_PRECEDENCE,
-                                       allowCascades);

[Lasse Reichstein Nielsen, 2013/09/18 13:41:19]

WOuld it be better to keep the 'if' and the last two statements here?

[ahe, 2013/09/18 13:42:59]

Yes. And it would be even better if you replace listener.recoverableError with
listener.reportError.

-    } else if ((identical(value, '!')) ||
+    if ((identical(value, '!')) ||
                (identical(value, '-')) ||
                (identical(value, '~'))) {
       Token operator = token;
       // Right associative, so we recurse at the same precedence
       // level.
       token = parsePrecedenceExpression(token.next, POSTFIX_PRECEDENCE,
                                         allowCascades);
       listener.handleUnaryPrefixExpression(operator);
     } else if ((identical(value, '++')) || identical(value, '--')) {
       // TODO(ahe): Validate this is used correctly.
@@ skipping 747 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }