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 1487 matching lines @@
    * The next token to be parsed.
    */
   Token _currentToken;
 
   /**
    * A flag indicating whether the parser is currently in a function body marked as being 'async'.
    */
   bool _inAsync = false;
 
   /**
+   * A flag indicating whether the parser is currently in a function body marked as being 'async'.
+   */
+  bool _inGenerator = false;
+
+  /**
    * A flag indicating whether the parser is currently in the body of a loop.
    */
   bool _inLoop = false;
 
   /**
    * A flag indicating whether the parser is currently in a switch statement.
    */
   bool _inSwitch = false;
 
   /**
@@ skipping 3406 matching lines @@
    * </pre>
    *
    * @param mayBeEmpty `true` if the function body is allowed to be empty
    * @param emptyErrorCode the error code to report if function body expected, but not found
    * @param inExpression `true` if the function body is being parsed as part of an expression
    *          and therefore does not have a terminating semicolon
    * @return the function body that was parsed
    */
   FunctionBody _parseFunctionBody(bool mayBeEmpty, ParserErrorCode emptyErrorCode, bool inExpression) {
     bool wasInAsync = _inAsync;
+    bool wasInGenerator = _inGenerator;
     bool wasInLoop = _inLoop;
     bool wasInSwitch = _inSwitch;
     _inAsync = false;
+    _inGenerator = false;
     _inLoop = false;
     _inSwitch = false;
     try {
       if (_matches(TokenType.SEMICOLON)) {
         if (!mayBeEmpty) {
           _reportErrorForCurrentToken(emptyErrorCode, []);
         }
         return new EmptyFunctionBody(andAdvance);
       } else if (_matchesString(_NATIVE)) {
         Token nativeToken = andAdvance;
         StringLiteral stringLiteral = null;
         if (_matches(TokenType.STRING)) {
           stringLiteral = parseStringLiteral();
         }
         return new NativeFunctionBody(nativeToken, stringLiteral, _expect(TokenType.SEMICOLON));
       }
       Token keyword = null;
       Token star = null;
       if (_parseAsync) {
         if (_matchesString(ASYNC)) {
           keyword = andAdvance;
           if (_matches(TokenType.STAR)) {
             star = andAdvance;
+            _inGenerator = true;
           }
           _inAsync = true;
         } else if (_matchesString(SYNC)) {
           keyword = andAdvance;
           if (_matches(TokenType.STAR)) {
             star = andAdvance;
+            _inGenerator = true;
           }
         }
       }
       if (_matches(TokenType.FUNCTION)) {
         if (keyword != null) {
           if (!_tokenMatchesString(keyword, ASYNC)) {
             _reportErrorForToken(ParserErrorCode.INVALID_SYNC, keyword, []);
             keyword = null;
           } else if (star != null) {
             _reportErrorForToken(ParserErrorCode.INVALID_STAR_AFTER_ASYNC, star, []);
@@ skipping 20 matching lines @@
           return new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON));
         }
         return new BlockFunctionBody(keyword, star, parseBlock());
       } else {
         // Invalid function body
         _reportErrorForCurrentToken(emptyErrorCode, []);
         return new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON));
       }
     } finally {
       _inAsync = wasInAsync;
+      _inGenerator = wasInGenerator;
       _inLoop = wasInLoop;
       _inSwitch = wasInSwitch;
     }
   }
 
   /**
    * Parse a function declaration.
    *
    * <pre>
    * functionDeclaration ::=
@@ skipping 763 matching lines @@
         return _parseVariableDeclarationStatementAfterMetadata(commentAndMetadata);
       } else if (keyword == Keyword.NEW || keyword == Keyword.TRUE || keyword == Keyword.FALSE || keyword == Keyword.NULL || keyword == Keyword.SUPER || keyword == Keyword.THIS) {
         return new ExpressionStatement(parseExpression2(), _expect(TokenType.SEMICOLON));
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT, []);
         return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
       }
-    } else if (_inAsync && _matchesString(_YIELD)) {
+    } else if (_inGenerator && _matchesString(_YIELD)) {
       return _parseYieldStatement();
     } else if (_inAsync && _matchesString(_AWAIT)) {
       if (_tokenMatchesKeyword(_peek(), Keyword.FOR)) {
         return _parseForStatement();
       }
       return new ExpressionStatement(parseExpression2(), _expect(TokenType.SEMICOLON));
+    } else if (_matchesString(_AWAIT) && _tokenMatchesKeyword(_peek(), Keyword.FOR)) {
+      Token awaitToken = _currentToken;
+      Statement statement = _parseForStatement();
+      if (statement is! ForStatement) {
+        _reportErrorForToken(CompileTimeErrorCode.ASYNC_FOR_IN_WRONG_CONTEXT, awaitToken, []);
+      }
+      return statement;
     } else if (_matches(TokenType.SEMICOLON)) {
       return _parseEmptyStatement();
     } else if (_isInitializedVariableDeclaration()) {
       return _parseVariableDeclarationStatementAfterMetadata(commentAndMetadata);
     } else if (_isFunctionDeclaration()) {
       return _parseFunctionDeclarationStatement();
     } else if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT, []);
       return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
     } else {
@@ skipping 795 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 (_inAsync && _matchesString(_AWAIT)) {
+    } else if (_matchesString(_AWAIT)) {
       return _parseAwaitExpression();
     }
     return _parsePostfixExpression();
   }
 
   /**
    * Parse a variable declaration.
    *
    * <pre>
    * variableDeclaration ::=
@@ skipping 206 matching lines @@
     _reportError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void _reportErrorForToken(ParserErrorCode errorCode, Token token, List<Object> arguments) {
+  void _reportErrorForToken(ErrorCode errorCode, Token token, List<Object> arguments) {
     if (token.type == TokenType.EOF) {
       token = token.previous;
     }
     _reportError(new AnalysisError.con2(_source, token.offset, Math.max(token.length, 1), errorCode, arguments));
   }
 
   /**
    * Skips a block with all containing blocks.
    */
   void _skipBlock() {
@@ skipping 2625 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");
     }
   }
 }