assert isAsynchronous and isGenerator false if parseAsync is false

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 6083 matching lines @@
         }
         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);
+          keyword = null;

[Brian Wilkerson, 2016/01/13 21:38:01]

I don't think we want to make these changes to the parser (other than the error
code fix). As a general principle we capture the actual content of the file even
if it's invalid. More specifically, there are UX implications:
 - If we've already told the user that async isn't supported, then that should
be enough. Do we really want them to get an error every time they used an async
'for', 'await' or 'yield'?
 - If we have quick assists to help them convert their code it might be harder
to implement correctly if we've lost information.

Is there a problem that you're seeing that this fixes?

[danrubel, 2016/01/13 22:02:20]

Yes. There are a number of places in the resolver and elsewhere that first check
isAsynchronous and then access resolver.futureType, resolver.streamType, etc.
These will all be null if there is no dart:async library. This seemed the best
way to fix resolution when async is not supported.

An alternate approach is to revert this change and have the resolver define
placeholder/mock declarations and elements for Future and Stream when dart:async
is not available. Would that be a better approach?

         }
         if (_matches(TokenType.STAR)) {
           star = getAndAdvance();
+          if (!_parseAsync) {
+            star = null;
+          }
           _inGenerator = true;
         }
         _inAsync = true;
       } else if (_matchesString(SYNC)) {
         keyword = getAndAdvance();
         if (!_parseAsync) {
           _reportErrorForToken(ParserErrorCode.ASYNC_NOT_SUPPORTED, keyword);
+          keyword = null;
         }
         if (_matches(TokenType.STAR)) {
           star = getAndAdvance();
+          if (!_parseAsync) {
+            star = null;
+          }
           _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(
@@ skipping 3247 matching lines @@
    * 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.
    */
-  static const CompileTimeErrorCode ASYNC_NOT_SUPPORTED =
-      const CompileTimeErrorCode('ASYNC_NOT_SUPPORTED',
+  static const ParserErrorCode ASYNC_NOT_SUPPORTED =
+      const ParserErrorCode('ASYNC_NOT_SUPPORTED',
           "Async and sync are not supported in this environment.");
 
   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(
@@ skipping 1960 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);
   }
 }