add parser parseAsync flag

pkg/analyzer/lib/src/task/options.dart

 // Copyright (c) 2015, 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.task.options;
 
 import 'dart:collection';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/plugin/options.dart';
@@ skipping 21 matching lines @@
 
 /// Configure this [context] based on configuration details specified in
 /// the given [options].  If [options] is `null`, default values are applied.
 void configureContextOptions(
         AnalysisContext context, Map<String, Object> options) =>
     _processor.configure(context, options);
 
 /// `analyzer` analysis options constants.
 class AnalyzerOptions {
   static const String analyzer = 'analyzer';
+  static const String enableAsync = 'enableAsync';
   static const String enableGenericMethods = 'enableGenericMethods';
   static const String enableSuperMixins = 'enableSuperMixins';
   static const String errors = 'errors';
   static const String exclude = 'exclude';
   static const String language = 'language';
   static const String plugins = 'plugins';
   static const String strong_mode = 'strong-mode';
 
   /// Ways to say `ignore`.
   static const List<String> ignoreSynonyms = const ['ignore', 'false'];
@@ skipping 12 matching lines @@
   static const List<String> topLevel = const [
     errors,
     exclude,
     language,
     plugins,
     strong_mode
   ];
 
   /// Supported `analyzer` language configuration options.
   static const List<String> languageOptions = const [
+    enableAsync,
     enableGenericMethods,
     enableSuperMixins
   ];
 }
 
 /// Validates `analyzer` options.
 class AnalyzerOptionsValidator extends CompositeValidator {
   AnalyzerOptionsValidator()
       : super([
           new TopLevelAnalyzerOptionsValidator(),
@@ skipping 334 matching lines @@
     var filters = analyzer[AnalyzerOptions.errors];
     setProcessors(context, filters);
 
     // Process language options.
     var language = analyzer[AnalyzerOptions.language];
     setLanguageOptions(context, language);
   }
 
   void setLanguageOption(
       AnalysisContext context, Object feature, Object value) {
+    if (feature == AnalyzerOptions.enableAsync) {
+      if (isFalse(value)) {
+        AnalysisOptionsImpl options =
+            new AnalysisOptionsImpl.from(context.analysisOptions);

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

Seems kind of wasteful to create a new options object for every flag. It might
not matter much in terms of performance, though.

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

I don't think this is a performance bottleneck, so I did not spend the time to
optimize the performance.

+        options.enableAsync = false;
+        context.analysisOptions = options;
+      }
+    }
     if (feature == AnalyzerOptions.enableSuperMixins) {
       if (isTrue(value)) {
         AnalysisOptionsImpl options =
             new AnalysisOptionsImpl.from(context.analysisOptions);
         options.enableSuperMixins = true;
         context.analysisOptions = options;
       }
     }
     if (feature == AnalyzerOptions.enableGenericMethods) {
       if (isTrue(value)) {
@@ skipping 27 matching lines @@
   void setStrongMode(AnalysisContext context, Object strongMode) {
     bool strong = strongMode is bool ? strongMode : false;
     if (context.analysisOptions.strongMode != strong) {
       AnalysisOptionsImpl options =
           new AnalysisOptionsImpl.from(context.analysisOptions);
       options.strongMode = strong;
       context.analysisOptions = options;
     }
   }
 }