New analyzer snapshot.

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

 // Copyright (c) 2014, 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.
 
 // 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';
@@ skipping 1879 matching lines @@
       _validateModifiersForOperator(modifiers);
       return _parseOperator(commentAndMetadata, modifiers.externalKeyword, null);
     } else if (!_matchesIdentifier()) {
       if (_isOperator(_currentToken)) {
         //
         // We appear to have found an operator declaration without the 'operator' keyword.
         //
         _validateModifiersForOperator(modifiers);
         return _parseOperator(commentAndMetadata, modifiers.externalKeyword, null);
       }
+      Token keyword = modifiers.varKeyword;
+      if (keyword == null) {
+        keyword = modifiers.finalKeyword;
+      }
+      if (keyword == null) {
+        keyword = modifiers.constKeyword;
+      }
+      if (keyword != null) {
+        //
+        // We appear to have found an incomplete field declaration.
+        //
+        _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER, []);
+        List<VariableDeclaration> variables = new List<VariableDeclaration>();
+        variables.add(new VariableDeclaration(null, null, _createSyntheticIdentifier(), null, null));
+        return new FieldDeclaration(commentAndMetadata.comment, commentAndMetadata.metadata, null, new VariableDeclarationList(null, null, keyword, null, variables), _expectSemicolon());
+      }
       _reportErrorForToken(ParserErrorCode.EXPECTED_CLASS_MEMBER, _currentToken, []);
       if (commentAndMetadata.comment != null || !commentAndMetadata.metadata.isEmpty) {
         //
         // We appear to have found an incomplete declaration at the end of the class. At this point
         // it consists of a metadata, which we don't want to loose, so we'll treat it as a method
         // declaration with a missing name, parameters and empty body.
         //
         return new MethodDeclaration(commentAndMetadata.comment, commentAndMetadata.metadata, null, null, null, null, null, _createSyntheticIdentifier(), new FormalParameterList(null, new List<FormalParameter>(), null, null, null), new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
@@ skipping 229 matching lines @@
    * </pre>
    *
    * @return the expression that was parsed
    */
   Expression parseExpression2() {
     if (_matchesKeyword(Keyword.THROW)) {
       return _parseThrowExpression();
     } else if (_matchesKeyword(Keyword.RETHROW)) {
       // TODO(brianwilkerson) Rethrow is a statement again.
       return _parseRethrowExpression();
-    } else if (_parseAsync && _matchesString(_AWAIT)) {
-      return _parseAwaitExpression();
     }
     //
     // assignableExpression is a subset of conditionalExpression, so we can parse a conditional
     // expression and then determine whether it is followed by an assignmentOperator, checking for
     // conformance to the restricted grammar after making that determination.
     //
     Expression expression = parseConditionalExpression();
     TokenType tokenType = _currentToken.type;
     if (tokenType == TokenType.PERIOD_PERIOD) {
       List<Expression> cascadeSections = new List<Expression>();
@@ skipping 1476 matching lines @@
       }
       return prefix;
     }
   }
 
   /**
    * Parse a await expression.
    *
    * <pre>
    * awaitExpression ::=
-   *     'await' expression ';'
+   *     'await' unaryExpression
    * </pre>
    *
    * @return the await expression that was parsed
    */
   AwaitExpression _parseAwaitExpression() {
     Token awaitToken = andAdvance;
-    Expression expression = parseExpression2();
-    Token semicolon = _expect(TokenType.SEMICOLON);
-    return new AwaitExpression(awaitToken, expression, semicolon);
+    Expression expression = _parseUnaryExpression();
+    return new AwaitExpression(awaitToken, expression);
   }
 
   /**
    * Parse a bitwise and expression.
    *
    * <pre>
    * bitwiseAndExpression ::=
    *     shiftExpression ('&' shiftExpression)*
    *   | 'super' ('&' shiftExpression)+
    * </pre>
@@ skipping 569 matching lines @@
         _reportErrorForToken(ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken, []);
         return null;
       }
     } else if ((_matchesKeyword(Keyword.GET) || _matchesKeyword(Keyword.SET)) && _tokenMatchesIdentifier(_peek())) {
       _validateModifiersForTopLevelFunction(modifiers);
       return _parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
     } else if (_matchesKeyword(Keyword.OPERATOR) && _isOperator(_peek())) {
       _reportErrorForToken(ParserErrorCode.TOP_LEVEL_OPERATOR, _currentToken, []);
       return _convertToFunctionDeclaration(_parseOperator(commentAndMetadata, modifiers.externalKeyword, null));
     } else if (!_matchesIdentifier()) {
+      Token keyword = modifiers.varKeyword;
+      if (keyword == null) {
+        keyword = modifiers.finalKeyword;
+      }
+      if (keyword == null) {
+        keyword = modifiers.constKeyword;
+      }
+      if (keyword != null) {
+        //
+        // We appear to have found an incomplete top-level variable declaration.
+        //
+        _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER, []);
+        List<VariableDeclaration> variables = new List<VariableDeclaration>();
+        variables.add(new VariableDeclaration(null, null, _createSyntheticIdentifier(), null, null));
+        return new TopLevelVariableDeclaration(commentAndMetadata.comment, commentAndMetadata.metadata, new VariableDeclarationList(null, null, keyword, null, variables), _expectSemicolon());
+      }
       _reportErrorForToken(ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken, []);
       return null;
     } else if (_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       _validateModifiersForTopLevelFunction(modifiers);
       return _parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
     } else if (_peek().matchesAny([TokenType.EQ, TokenType.COMMA, TokenType.SEMICOLON])) {
       if (modifiers.constKeyword == null && modifiers.finalKeyword == null && modifiers.varKeyword == null) {
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, []);
       }
       return new TopLevelVariableDeclaration(commentAndMetadata.comment, commentAndMetadata.metadata, _parseVariableDeclarationListAfterType(null, _validateModifiersForTopLevelVariable(modifiers), null), _expect(TokenType.SEMICOLON));
@@ skipping 2244 matching lines @@
     }
     return _parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
   /**
    * Parse a unary expression.
    *
    * <pre>
    * unaryExpression ::=
    *     prefixOperator unaryExpression
+   *   | awaitExpression
    *   | postfixExpression
    *   | unaryOperator 'super'
    *   | '-' 'super'
    *   | incrementOperator assignableExpression
    * </pre>
    *
    * @return the unary expression that was parsed
    */
   Expression _parseUnaryExpression() {
     if (_matches(TokenType.MINUS) || _matches(TokenType.BANG) || _matches(TokenType.TILDE)) {
@@ skipping 32 matching lines @@
         } else {
           // Invalid operator before 'super'
           _reportErrorForCurrentToken(ParserErrorCode.INVALID_OPERATOR_FOR_SUPER, [operator.lexeme]);
           return new PrefixExpression(operator, new SuperExpression(andAdvance));
         }
       }
       return new PrefixExpression(operator, _parseAssignableExpression(false));
     } else if (_matches(TokenType.PLUS)) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER, []);
       return _createSyntheticIdentifier();
+    } else if (_parseAsync && _matchesString(_AWAIT)) {
+      return _parseAwaitExpression();
     }
     return _parsePostfixExpression();
   }
 
   /**
    * Parse a variable declaration.
    *
    * <pre>
    * variableDeclaration ::=
    *     identifier ('=' expression)?
@@ skipping 1717 matching lines @@
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
   @override
   bool visitAwaitExpression(AwaitExpression node) {
     AwaitExpression toNode = this._toNode as AwaitExpression;
-    return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.awaitKeyword, toNode.awaitKeyword), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.semicolon, toNode.semicolon));
+    return javaBooleanAnd(_isEqualTokens(node.awaitKeyword, toNode.awaitKeyword), _isEqualNodes(node.expression, toNode.expression));
   }
 
   @override
   bool visitBinaryExpression(BinaryExpression node) {
     BinaryExpression toNode = this._toNode as BinaryExpression;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.leftOperand, toNode.leftOperand), _isEqualTokens(node.operator, toNode.operator)), _isEqualNodes(node.rightOperand, toNode.rightOperand))) {
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
@@ skipping 1113 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }