add parser parseAsync flag

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.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 2090 matching lines @@
    * during the parse.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * An [errorListener] lock, if more than `0`, then errors are not reported.
    */
   int _errorListenerLock = 0;
 
   /**
+   * A flag indicating whether the parser is to parse the async support.
+   */
+  bool _parseAsync = true;
+
+  /**
    * A flag indicating whether parser is to parse function bodies.
    */
   bool _parseFunctionBodies = true;
 
   /**
    * The next token to be parsed.
    */
   Token _currentToken;
 
   /**
@@ skipping 60 matching lines @@
    */
   bool get hasReturnTypeInTypeAlias {
     Token next = _skipReturnType(_currentToken);
     if (next == null) {
       return false;
     }
     return _tokenMatchesIdentifier(next);
   }
 
   /**
+   * Set whether the parser is to parse the async support.
+   */
+  void set parseAsync(bool parseAsync) {
+    this._parseAsync = parseAsync;
+  }
+
+  /**
    * Set whether parser is to parse function bodies.
    */
   void set parseFunctionBodies(bool parseFunctionBodies) {
     this._parseFunctionBodies = parseFunctionBodies;
   }
 
   /**
    * Advance to the next token in the token stream, making it the new current
    * token and return the token that was current before this method was invoked.
    */
@@ skipping 3879 matching lines @@
         if (_matches(TokenType.STRING)) {
           stringLiteral = parseStringLiteral();
         }
         return new NativeFunctionBody(
             nativeToken, stringLiteral, _expect(TokenType.SEMICOLON));
       }
       Token keyword = null;
       Token star = null;
       if (_matchesString(ASYNC)) {
         keyword = getAndAdvance();
+        if (!_parseAsync) {
+          _reportErrorForToken(ParserErrorCode.ASYNC_NOT_SUPPORTED, keyword);
+        }
         if (_matches(TokenType.STAR)) {
           star = getAndAdvance();
           _inGenerator = true;
         }
         _inAsync = true;
       } else if (_matchesString(SYNC)) {
         keyword = getAndAdvance();
+        if (!_parseAsync) {
+          _reportErrorForToken(ParserErrorCode.ASYNC_NOT_SUPPORTED, keyword);
+        }
         if (_matches(TokenType.STAR)) {
           star = getAndAdvance();
           _inGenerator = true;
         }
       }
       if (_matches(TokenType.FUNCTION)) {
         if (keyword != null) {
           if (!_tokenMatchesString(keyword, ASYNC)) {
             _reportErrorForToken(ParserErrorCode.INVALID_SYNC, keyword);
             keyword = null;
@@ skipping 3246 matching lines @@
 
   /**
    * 16.32 Identifier Reference: It is a compile-time error if any of the
    * identifiers async, await, or yield is used as an identifier in a function
    * body marked with either async, async*, or sync*.
    */
   static const ParserErrorCode ASYNC_KEYWORD_USED_AS_IDENTIFIER =
       const ParserErrorCode('ASYNC_KEYWORD_USED_AS_IDENTIFIER',
           "The keywords 'async', 'await', and 'yield' may not be used as identifiers in an asynchronous or generator function.");
 
+  /**
+   * Some environments such as fletch do not support async.

[Brian Wilkerson, 2016/01/08 18:43:47]

"fletch" or "Fletch"?

"environments such as fletch do" --> "environments, such as fletch, do"

And is that true, that none of the platforms that Fletch supports will include
async support?

[danrubel, 2016/01/08 20:45:51]

Done.

+   */
+  static const CompileTimeErrorCode ASYNC_NOT_SUPPORTED =
+      const CompileTimeErrorCode('ASYNC_NOT_SUPPORTED',
+          "Async and sync are not supported in this environment.");

[Brian Wilkerson, 2016/01/08 18:43:47]

"in this environment" or "on this platform"? What terminology makes the most
sense to users?

[danrubel, 2016/01/08 20:45:51]

Really good question... I struggled with this as well.
I'm happy to change it in a subsequent CL if we find better wording.

+
   static const ParserErrorCode BREAK_OUTSIDE_OF_LOOP = const ParserErrorCode(
       'BREAK_OUTSIDE_OF_LOOP',
       "A break statement cannot be used outside of a loop or switch statement");
 
   static const ParserErrorCode CLASS_IN_CLASS = const ParserErrorCode(
       'CLASS_IN_CLASS', "Classes cannot be declared inside other classes");
 
   static const ParserErrorCode COLON_IN_PLACE_OF_IN = const ParserErrorCode(
       'COLON_IN_PLACE_OF_IN', "For-in loops use 'in' rather than a colon");
 
@@ skipping 1958 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }