Revert "Attempt to change analyzer to parse the new order of operators."

pkg/analyzer_experimental/lib/src/generated/parser.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.parser;
 import 'dart:collection';
 import 'java_core.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
@@ skipping 1121 matching lines @@
       }
       return prefix;
     }
   }
 
   /**
    * Parse a bitwise and expression.
    *
    * <pre>
    * bitwiseAndExpression ::=
-   *     shiftExpression ('&' shiftExpression)*
-   *   | 'super' ('&' shiftExpression)+
+   *     equalityExpression ('&' equalityExpression)*
+   *   | 'super' ('&' equalityExpression)+
    * </pre>
    *
    * @return the bitwise and expression that was parsed
    */
   Expression parseBitwiseAndExpression() {
     Expression expression;
     if (matches(Keyword.SUPER) && matches4(peek(), TokenType.AMPERSAND)) {
       expression = new SuperExpression.full(andAdvance);
     } else {
-      expression = parseShiftExpression();
+      expression = parseEqualityExpression();
     }
     while (matches5(TokenType.AMPERSAND)) {
       Token operator = andAdvance;
-      expression = new BinaryExpression.full(expression, operator, parseShiftExpression());
+      expression = new BinaryExpression.full(expression, operator, parseEqualityExpression());
     }
     return expression;
   }
 
   /**
    * Parse a bitwise or expression.
    *
    * <pre>
    * bitwiseOrExpression ::=
    *     bitwiseXorExpression ('|' bitwiseXorExpression)*
@@ skipping 2020 matching lines @@
     }
     reportError8(ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL, []);
     return new ListLiteral.full(modifier, typeArguments, createSyntheticToken2(TokenType.OPEN_SQUARE_BRACKET), null, createSyntheticToken2(TokenType.CLOSE_SQUARE_BRACKET));
   }
 
   /**
    * Parse a logical and expression.
    *
    * <pre>
    * logicalAndExpression ::=
-   *     equalityExpression ('&&' equalityExpression)*
+   *     bitwiseOrExpression ('&&' bitwiseOrExpression)*
    * </pre>
    *
    * @return the logical and expression that was parsed
    */
   Expression parseLogicalAndExpression() {
-    Expression expression = parseEqualityExpression();
+    Expression expression = parseBitwiseOrExpression();
     while (matches5(TokenType.AMPERSAND_AMPERSAND)) {
       Token operator = andAdvance;
-      expression = new BinaryExpression.full(expression, operator, parseEqualityExpression());
+      expression = new BinaryExpression.full(expression, operator, parseBitwiseOrExpression());
     }
     return expression;
   }
 
   /**
    * Parse a logical or expression.
    *
    * <pre>
    * logicalOrExpression ::=
    *     logicalAndExpression ('||' logicalAndExpression)*
@@ skipping 688 matching lines @@
     }
     ArgumentList argumentList = parseArgumentList();
     return new RedirectingConstructorInvocation.full(keyword, period, constructorName, argumentList);
   }
 
   /**
    * Parse a relational expression.
    *
    * <pre>
    * relationalExpression ::=
-   *     bitwiseOrExpression ('is' '!'? type | 'as' type | relationalOperator bitwiseOrExpression)?
+   *     shiftExpression ('is' '!'? type | 'as' type | relationalOperator shiftExpression)?
    *   | 'super' relationalOperator shiftExpression
    * </pre>
    *
    * @return the relational expression that was parsed
    */
   Expression parseRelationalExpression() {
     if (matches(Keyword.SUPER) && _currentToken.next.type.isRelationalOperator) {
       Expression expression = new SuperExpression.full(andAdvance);
       Token operator = andAdvance;
-      expression = new BinaryExpression.full(expression, operator, parseBitwiseOrExpression());
+      expression = new BinaryExpression.full(expression, operator, parseShiftExpression());
       return expression;
     }
-    Expression expression = parseBitwiseOrExpression();
+    Expression expression = parseShiftExpression();
     if (matches(Keyword.AS)) {
       Token asOperator = andAdvance;
       expression = new AsExpression.full(expression, asOperator, parseTypeName());
     } else if (matches(Keyword.IS)) {
       Token isOperator = andAdvance;
       Token notOperator = null;
       if (matches5(TokenType.BANG)) {
         notOperator = andAdvance;
       }
       expression = new IsExpression.full(expression, isOperator, notOperator, parseTypeName());
     } else if (_currentToken.type.isRelationalOperator) {
       Token operator = andAdvance;
-      expression = new BinaryExpression.full(expression, operator, parseBitwiseOrExpression());
+      expression = new BinaryExpression.full(expression, operator, parseShiftExpression());
     }
     return expression;
   }
 
   /**
    * Parse a rethrow expression.
    *
    * <pre>
    * rethrowExpression ::=
    *     'rethrow'
@@ skipping 2892 matching lines @@
       if ("\n" == separator) {
         _writer.print("\n");
         indent();
       } else if (i > 0) {
         _writer.print(separator);
       }
       _writer.print(tokens[i].lexeme);
     }
   }
 }