Make analyzer_cli batch mode asynchronous.

pkg/analyzer_cli/lib/src/driver.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_cli.src.driver;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io' as io;
 
@@ skipping 50 matching lines @@
 ///
 /// *Visible for testing.*
 StringSink outSink = io.stdout;
 
 /// Test this option map to see if it specifies lint rules.
 bool containsLintRuleEntry(Map<String, YamlNode> options) {
   var linterNode = options['linter'];
   return linterNode is YamlMap && linterNode.containsKey('rules');
 }
 
-typedef ErrorSeverity _BatchRunnerHandler(List<String> args);
+typedef Future<ErrorSeverity> _BatchRunnerHandler(List<String> args);
 
 class Driver implements CommandLineStarter {
   static final PerformanceTag _analyzeAllTag =
       new PerformanceTag("Driver._analyzeAll");
 
   /// The plugins that are defined outside the `analyzer_cli` package.
   List<Plugin> _userDefinedPlugins = <Plugin>[];
 
   /// The context that was most recently created by a call to [_analyzeAll], or
   /// `null` if [_analyzeAll] hasn't been called yet.
@@ skipping 25 matching lines @@
   ///
   /// *Visible for testing.*
   AnalysisContext get context => _context;
 
   @override
   void set userDefinedPlugins(List<Plugin> plugins) {
     _userDefinedPlugins = plugins ?? <Plugin>[];
   }
 
   @override
-  void start(List<String> args) {
+  Future<Null> start(List<String> args) async {
     if (_context != null) {
       throw new StateError("start() can only be called once");
     }
     int startTime = new DateTime.now().millisecondsSinceEpoch;
 
     StringUtilities.INTERNER = new MappedInterner();
 
     _processPlugins();
 
     // Parse commandline options.
     CommandLineOptions options = CommandLineOptions.parse(args);
 
     // Do analysis.
     if (options.buildMode) {
       ErrorSeverity severity = _buildModeAnalyze(options);
       // In case of error propagate exit code.
       if (severity == ErrorSeverity.ERROR) {
         io.exitCode = severity.ordinal;
       }
     } else if (options.shouldBatch) {
       _BatchRunner.runAsBatch(args, (List<String> args) {
         CommandLineOptions options = CommandLineOptions.parse(args);
         return _analyzeAll(options);
       });
     } else {
-      ErrorSeverity severity = _analyzeAll(options);
+      ErrorSeverity severity = await _analyzeAll(options);
       // In case of error propagate exit code.
       if (severity == ErrorSeverity.ERROR) {
         io.exitCode = severity.ordinal;
       }
     }
 
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
     if (options.perfReport != null) {
       String json = makePerfReport(
           startTime, currentTimeMillis(), options, _analyzedFileCount, stats);
       new io.File(options.perfReport).writeAsStringSync(json);
     }
   }
 
-  ErrorSeverity _analyzeAll(CommandLineOptions options) {
-    return _analyzeAllTag.makeCurrentWhile(() {
-      return _analyzeAllImpl(options);
-    });
+  Future<ErrorSeverity> _analyzeAll(CommandLineOptions options) async {
+    PerformanceTag previous = _analyzeAllTag.makeCurrent();
+    try {
+      return await _analyzeAllImpl(options);
+    } finally {
+      previous.makeCurrent();
+    }
   }
 
   /// Perform analysis according to the given [options].
-  ErrorSeverity _analyzeAllImpl(CommandLineOptions options) {
+  Future<ErrorSeverity> _analyzeAllImpl(CommandLineOptions options) async {
     if (!options.machineFormat) {
       outSink.writeln("Analyzing ${options.sourceFiles}...");
     }
 
     // Create a context, or re-use the previous one.
     try {
       _createAnalysisContext(options);
     } on _DriverError catch (error) {
       outSink.writeln(error.msg);
       return ErrorSeverity.ERROR;
@@ skipping 31 matching lines @@
 
     // Analyze the libraries.
     ErrorSeverity allResult = ErrorSeverity.NONE;
     var libUris = <Uri>[];
     var parts = <Source>[];
     for (Source source in sourcesToAnalyze) {
       if (context.computeKindOf(source) == SourceKind.PART) {
         parts.add(source);
         continue;
       }
-      ErrorSeverity status = _runAnalyzer(source, options);
+      ErrorSeverity status = await _runAnalyzer(source, options);
       allResult = allResult.max(status);
       libUris.add(source.uri);
     }
 
     // Check that each part has a corresponding source in the input list.
     for (Source part in parts) {
       bool found = false;
       for (var lib in context.getLibrariesContaining(part)) {
         if (libUris.contains(lib.uri)) {
           found = true;
@@ skipping 298 matching lines @@
 
     AnalyzeFunctionBodiesPredicate dietParsingPolicy =
         _chooseDietParsingPolicy(options);
     setAnalysisContextOptions(
         resourceProvider, sourceFactory, _context, options,
         (AnalysisOptionsImpl contextOptions) {
       contextOptions.analyzeFunctionBodiesPredicate = dietParsingPolicy;
     });
 
     _context.sourceFactory = sourceFactory;
+
     if (sdkBundle != null) {
       _context.resultProvider =
           new InputPackagesResultProvider(_context, summaryDataStore);
     }
   }
 
   /// Return discovered packagespec, or `null` if none is found.
   Packages _discoverPackagespec(Uri root) {
     try {
       Packages packages = pkg_discovery.findPackagesFromFile(root);
@@ skipping 77 matching lines @@
     plugins.addAll(AnalysisEngine.instance.requiredPlugins);
     plugins.addAll(_userDefinedPlugins);
 
     ExtensionManager manager = new ExtensionManager();
     manager.processPlugins(plugins);
 
     linter.registerLintRules();
   }
 
   /// Analyze a single source.
-  ErrorSeverity _runAnalyzer(Source source, CommandLineOptions options) {
+  Future<ErrorSeverity> _runAnalyzer(
+      Source source, CommandLineOptions options) async {
     int startTime = currentTimeMillis();
-    AnalyzerImpl analyzer =
-        new AnalyzerImpl(_context, source, options, stats, startTime);
-    var errorSeverity = analyzer.analyzeSync();
+    AnalyzerImpl analyzer = new AnalyzerImpl(
+        _context.analysisOptions, _context, source, options, stats, startTime);
+    ErrorSeverity errorSeverity = await analyzer.analyze();
     if (errorSeverity == ErrorSeverity.ERROR) {
       io.exitCode = errorSeverity.ordinal;
     }
     if (options.warningsAreFatal && errorSeverity == ErrorSeverity.WARNING) {
       io.exitCode = errorSeverity.ordinal;
     }
     return errorSeverity;
   }
 
   void _setupSdk(CommandLineOptions options, bool useSummaries) {
@@ skipping 151 matching lines @@
   static void runAsBatch(List<String> sharedArgs, _BatchRunnerHandler handler) {
     outSink.writeln('>>> BATCH START');
     Stopwatch stopwatch = new Stopwatch();
     stopwatch.start();
     int testsFailed = 0;
     int totalTests = 0;
     ErrorSeverity batchResult = ErrorSeverity.NONE;
     // Read line from stdin.
     Stream cmdLine =
         io.stdin.transform(UTF8.decoder).transform(new LineSplitter());
-    cmdLine.listen((String line) {
+    cmdLine.listen((String line) async {
       // Maybe finish.
       if (line.isEmpty) {
         var time = stopwatch.elapsedMilliseconds;
         outSink.writeln(
             '>>> BATCH END (${totalTests - testsFailed}/$totalTests) ${time}ms');
         io.exitCode = batchResult.ordinal;
       }
       // Prepare arguments.
       var lineArgs = line.split(new RegExp('\\s+'));
       var args = new List<String>();
       args.addAll(sharedArgs);
       args.addAll(lineArgs);
       args.remove('-b');
       args.remove('--batch');
       // Analyze single set of arguments.
       try {
         totalTests++;
-        ErrorSeverity result = handler(args);
+        ErrorSeverity result = await handler(args);
         bool resultPass = result != ErrorSeverity.ERROR;
         if (!resultPass) {
           testsFailed++;
         }
         batchResult = batchResult.max(result);
         // Write stderr end token and flush.
         errorSink.writeln('>>> EOF STDERR');
         String resultPassString = resultPass ? 'PASS' : 'FAIL';
         outSink.writeln(
             '>>> TEST $resultPassString ${stopwatch.elapsedMilliseconds}ms');
@@ skipping 36 matching lines @@
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }