Make analyzer_cli batch mode asynchronous.

pkg/analyzer_cli/lib/src/analyzer_impl.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.analyzer_impl;
 
+import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
@@ skipping 13 matching lines @@
 /// Analyzes single library [File].
 class AnalyzerImpl {
   static final PerformanceTag _prepareErrorsTag =
       new PerformanceTag("AnalyzerImpl.prepareErrors");
   static final PerformanceTag _resolveLibraryTag =
       new PerformanceTag("AnalyzerImpl._resolveLibrary");
 
   final CommandLineOptions options;
   final int startTime;
 
+  final AnalysisOptions analysisOptions;
   final AnalysisContext context;
 
   /// Accumulated analysis statistics.
   final AnalysisStats stats;
 
   final Source librarySource;
 
   /// All [Source]s references by the analyzed library.
   final Set<Source> sources = new Set<Source>();
 
   /// All [AnalysisErrorInfo]s in the analyzed library.
   final List<AnalysisErrorInfo> errorInfos = new List<AnalysisErrorInfo>();
 
   /// [HashMap] between sources and analysis error infos.
   final HashMap<Source, AnalysisErrorInfo> sourceErrorsMap =
       new HashMap<Source, AnalysisErrorInfo>();
 
   /// If the file specified on the command line is part of a package, the name
   /// of that package.  Otherwise `null`.  This allows us to analyze the file
   /// specified on the command line as though it is reached via a "package:"
   /// URI, but avoid suppressing its output in the event that the user has not
   /// specified the "--package-warnings" option.
   String _selfPackageName;
 
-  AnalyzerImpl(this.context, this.librarySource, this.options, this.stats,
-      this.startTime);
+  AnalyzerImpl(this.analysisOptions, this.context, this.librarySource,
+      this.options, this.stats, this.startTime);
 
   /// Returns the maximal [ErrorSeverity] of the recorded errors.
   ErrorSeverity get maxErrorSeverity {
     var status = ErrorSeverity.NONE;
     for (AnalysisErrorInfo errorInfo in errorInfos) {
       for (AnalysisError error in errorInfo.errors) {
         if (_processError(error) == null) {
           continue;
         }
         var severity = computeSeverity(error, options);
@@ skipping 28 matching lines @@
     }
     // Add referenced libraries.
     for (LibraryElement child in library.importedLibraries) {
       addLibrarySources(child, libraries, units);
     }
     for (LibraryElement child in library.exportedLibraries) {
       addLibrarySources(child, libraries, units);
     }
   }
 
-  /// Treats the [sourcePath] as the top level library and analyzes it using a
-  /// synchronous algorithm over the analysis engine. If [printMode] is `0`,
-  /// then no error or performance information is printed. If [printMode] is `1`,
-  /// then both will be printed. If [printMode] is `2`, then only performance
-  /// information will be printed, and it will be marked as being for a cold VM.
-  ErrorSeverity analyzeSync({int printMode: 1}) {
+  /// Treats the [sourcePath] as the top level library and analyzes it using
+  /// the analysis engine. If [printMode] is `0`, then no error or performance
+  /// information is printed. If [printMode] is `1`, then both will be printed.
+  /// If [printMode] is `2`, then only performance information will be printed,
+  /// and it will be marked as being for a cold VM.
+  Future<ErrorSeverity> analyze({int printMode: 1}) async {
     setupForAnalysis();
-    return _analyzeSync(printMode);
+    return await _analyze(printMode);
   }
 
   /// Fills [errorInfos] using [sources].
-  void prepareErrors() {
-    return _prepareErrorsTag.makeCurrentWhile(() {
+  Future<Null> prepareErrors() async {
+    PerformanceTag previous = _prepareErrorsTag.makeCurrent();
+    try {
       for (Source source in sources) {
         context.computeErrors(source);
         errorInfos.add(context.getErrors(source));
       }
-    });
+    } finally {
+      previous.makeCurrent();
+    }
   }
 
   /// Fills [sources].
   void prepareSources(LibraryElement library) {
     var units = new Set<CompilationUnitElement>();
     var libraries = new Set<LibraryElement>();
     addLibrarySources(library, libraries, units);
   }
 
   /// Setup local fields such as the analysis context for analysis.
   void setupForAnalysis() {
     sources.clear();
     errorInfos.clear();
     Uri libraryUri = librarySource.uri;
     if (libraryUri.scheme == 'package' && libraryUri.pathSegments.length > 0) {
       _selfPackageName = libraryUri.pathSegments[0];
     }
   }
 
-  /// The sync version of analysis.
-  ErrorSeverity _analyzeSync(int printMode) {
+  Future<ErrorSeverity> _analyze(int printMode) async {
     // Don't try to analyze parts.
     if (context.computeKindOf(librarySource) == SourceKind.PART) {
       stderr.writeln("Only libraries can be analyzed.");
       stderr.writeln(
           "${librarySource.fullName} is a part and can not be analyzed.");
       return ErrorSeverity.ERROR;
     }
-    var libraryElement = _resolveLibrary();
+    LibraryElement libraryElement = await _resolveLibrary();
     prepareSources(libraryElement);
-    prepareErrors();
+    await prepareErrors();
 
     // Print errors and performance numbers.
     if (printMode == 1) {
       _printErrors();
     } else if (printMode == 2) {
       _printColdPerf();
     }
 
     // Compute max severity and set exitCode.
     ErrorSeverity status = maxErrorSeverity;
@@ skipping 60 matching lines @@
     // "cannot have the batch flag and source file" error message.
     StringSink sink = options.machineFormat ? errorSink : outSink;
 
     // Print errors.
     ErrorFormatter formatter =
         new ErrorFormatter(sink, options, stats, _processError);
     formatter.formatErrors(errorInfos);
   }
 
   ProcessedSeverity _processError(AnalysisError error) =>
-      processError(error, options, context);
+      processError(error, options, analysisOptions);
 
-  LibraryElement _resolveLibrary() {
-    return _resolveLibraryTag.makeCurrentWhile(() {
+  Future<LibraryElement> _resolveLibrary() async {
+    PerformanceTag previous = _resolveLibraryTag.makeCurrent();
+    try {
       return context.computeLibraryElement(librarySource);
-    });
+    } finally {
+      previous.makeCurrent();
+    }
   }
 
   /// Compute the severity of the error; however:
   ///   * if [options.enableTypeChecks] is false, then de-escalate checked-mode
   ///   compile time errors to a severity of [ErrorSeverity.INFO].
   ///   * if [options.hintsAreFatal] is true, escalate hints to errors.
   ///   * if [options.lintsAreFatal] is true, escalate lints to errors.
   static ErrorSeverity computeSeverity(
       AnalysisError error, CommandLineOptions options,
-      [AnalysisContext context]) {
-    if (context != null) {
+      [AnalysisOptions analysisOptions]) {
+    if (analysisOptions != null) {
       ErrorProcessor processor =
-          ErrorProcessor.getProcessor(context.analysisOptions, error);
+          ErrorProcessor.getProcessor(analysisOptions, error);
       // If there is a processor for this error, defer to it.
       if (processor != null) {
         return processor.severity;
       }
     }
 
     if (!options.enableTypeChecks &&
         error.errorCode.type == ErrorType.CHECKED_MODE_COMPILE_TIME_ERROR) {
       return ErrorSeverity.INFO;
     } else if (options.hintsAreFatal && error.errorCode is HintCode) {
@@ skipping 17 matching lines @@
       }
       dir = dir.getParentFile();
     }
     // Not found.
     return null;
   }
 
   /// Check various configuration options to get a desired severity for this
   /// [error] (or `null` if it's to be suppressed).
   static ProcessedSeverity processError(AnalysisError error,
-      CommandLineOptions options, AnalysisContext context) {
-    ErrorSeverity severity = computeSeverity(error, options, context);
+      CommandLineOptions options, AnalysisOptions analysisOptions) {
+    ErrorSeverity severity = computeSeverity(error, options, analysisOptions);
     bool isOverridden = false;
 
     // Skip TODOs categorically (unless escalated to ERROR or HINT.)
     // https://github.com/dart-lang/sdk/issues/26215
     if (error.errorCode.type == ErrorType.TODO &&
         severity == ErrorSeverity.INFO) {
       return null;
     }
 
     // First check for a filter.
@@ skipping 44 matching lines @@
   }
 
   @override
   void logInformation(String message, [CaughtException exception]) {
     outSink.writeln(message);
     if (exception != null) {
       outSink.writeln(exception);
     }
   }
 }