Convert the command line dart analyzer to be async.

pkg/analyzer/lib/src/analyzer_impl.dart

 // Copyright (c) 2013, 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_impl;
 
+import 'dart:async';
+
 import 'dart:io';
 
+import 'package:analyzer/src/error_formatter.dart';
+import 'package:analyzer/src/generated/java_core.dart' show JavaSystem;
 import 'package:path/path.dart' as pathos;
 
 import 'generated/java_io.dart';
 import 'generated/engine.dart';
 import 'generated/error.dart';
 import 'generated/source_io.dart';
 import 'generated/sdk.dart';
 import 'generated/sdk_io.dart';
-import 'generated/ast.dart';
 import 'generated/element.dart';
 import '../options.dart';
 
-
 DartSdk sdk;
 
 /// Analyzes single library [File].
 class AnalyzerImpl {
+  final String sourcePath;
   final CommandLineOptions options;
+  int startTime;
 
   ContentCache contentCache = new ContentCache();
   SourceFactory sourceFactory;
   AnalysisContext context;
 
   /// 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>();
 
-  AnalyzerImpl(CommandLineOptions this.options) {
+  AnalyzerImpl(String this.sourcePath, CommandLineOptions this.options, int this.startTime) {

[Brian Wilkerson, 2014/03/11 18:36:53]

Don't include type annotations for field initializer formal parameters.

[jwren, 2014/03/11 21:53:04]

Done.

     if (sdk == null) {
       sdk = new DirectoryBasedDartSdk(new JavaFile(options.dartSdkPath));
     }
   }
 
   /**
    * Treats the [sourcePath] as the top level library and analyzes it.
    */
-  void analyze(String sourcePath) {
+  void analyze() {
     sources.clear();
     errorInfos.clear();
     if (sourcePath == null) {
       throw new ArgumentError("sourcePath cannot be null");
     }
-    var sourceFile = new JavaFile(sourcePath);
-    var uriKind = getUriKind(sourceFile);
-    var librarySource = new FileBasedSource.con2(sourceFile, uriKind);
+    JavaFile sourceFile = new JavaFile(sourcePath);
+    UriKind uriKind = getUriKind(sourceFile);
+    Source librarySource = new FileBasedSource.con2(sourceFile, uriKind);
+
     // prepare context
-    prepareAnalysisContext(sourceFile);
-    // don't try to analyzer parts
-    var unit = context.parseCompilationUnit(librarySource);
-    var hasLibraryDirective = false;
-    var hasPartOfDirective = false;
-    for (var directive in unit.directives) {
-      if (directive is LibraryDirective) hasLibraryDirective = true;
-      if (directive is PartOfDirective) hasPartOfDirective = true;
-    }
-    if (hasPartOfDirective && !hasLibraryDirective) {
-      print("Only libraries can be analyzed.");
-      print("$sourceFile is a part and can not be analyzed.");
-      return;
-    }
-    // resolve library
-    var libraryElement = context.computeLibraryElement(librarySource);
-    // prepare source and errors
-    prepareSources(libraryElement);
-    prepareErrors();
+    prepareAnalysisContext(sourceFile, librarySource);
+
+    // async perform all tasks in context
+   _analyze();
+  }
+
+  void _analyze() {

[Bob Nystrom, 2014/03/11 18:24:46]

Drive-by code review!

It's considered good style for any asynchronous code to return a Future.
Otherwise, the caller has no way of waiting until the operation has completed,
or catching an error.

There are exceptions to this (for example, if you are intentionally doing work
in the background and piping the results to a stream), but these are rare.

Even though this function is private, it's still helpful to return the future
because it makes it clear to the reader that this is doing asynchronous work.

[jwren, 2014/03/11 21:53:04]

Bob- Thanks for the feedback.  For now we are going to leaving it as-is (since
it is private as you pointed out) and will revisit in the future.

+    new Future(context.performAnalysisTask).then((AnalysisResult result) {
+        List<ChangeNotice> notices = result.changeNotices;

[Bob Nystrom, 2014/03/11 18:24:46]

Style nit: this function body should be indented +2 relative to "new Future".

[jwren, 2014/03/11 21:53:04]

Done.

+        // TODO(jwren) change notices != null to result.isMoreWork after new
+        // dart translation is landed
+        if(notices != null) {

[Bob Nystrom, 2014/03/11 18:24:46]

Space after "if".

[Brian Wilkerson, 2014/03/11 18:36:53]

You're not making use of the utility method you defined. I assume that's because
it hasn't been translated yet.

[jwren, 2014/03/11 21:53:04]

Done.
Correct.

+          // There is more work, record the set of sources, and then call self
+          // again to perform next task
+          for(ChangeNotice notice in notices) {

[Brian Wilkerson, 2014/03/11 18:36:53]

nit: space after "for"

[jwren, 2014/03/11 21:53:04]

Done.

+            sources.add(notice.source);
+          }
+          return _analyze();
+        } else {

[Bob Nystrom, 2014/03/11 18:24:46]

Friendly suggestion: Since the if case always returns, the else is unneeded
here. That would let you get rid of a level of indentation.

[jwren, 2014/03/11 21:53:04]

Done.

+          //
+          // There are not any more tasks, set error code and print performance
+          // numbers.
+          //
+          // prepare errors
+          prepareErrors();
+
+          // compute max severity and set exitCode
+          ErrorSeverity status = maxErrorSeverity;
+          if (status == ErrorSeverity.WARNING && options.warningsAreFatal) {
+            status = ErrorSeverity.ERROR;
+          }
+          exitCode = status.ordinal;
+
+          // print errors
+          ErrorFormatter formatter = new ErrorFormatter(stdout, options);
+          formatter.formatErrors(errorInfos);
+
+          // print performance numbers
+          if (options.perf) {
+            int totalTime = JavaSystem.currentTimeMillis() - startTime;
+            int ioTime = PerformanceStatistics.io.result;
+            int scanTime = PerformanceStatistics.scan.result;
+            int parseTime = PerformanceStatistics.parse.result;
+            int resolveTime = PerformanceStatistics.resolve.result;
+            int errorsTime = PerformanceStatistics.errors.result;
+            int hintsTime = PerformanceStatistics.hints.result;
+            int angularTime = PerformanceStatistics.angular.result;
+            stdout.writeln("io:$ioTime");
+            stdout.writeln("scan:$scanTime");
+            stdout.writeln("parse:$parseTime");
+            stdout.writeln("resolve:$resolveTime");
+            stdout.writeln("errors:$errorsTime");
+            stdout.writeln("hints:$hintsTime");
+            stdout.writeln("angular:$angularTime");
+            stdout.writeln("other:${totalTime
+                 - (ioTime + scanTime + parseTime + resolveTime + errorsTime + hintsTime
+                 + angularTime)}");
+            stdout.writeln("total:$totalTime");
+          }
+        }
+      }).catchError((exception, stackTrace) {
+          AnalysisEngine.instance.logger.logError(exception);

[Bob Nystrom, 2014/03/11 18:24:46]

This only needs to be indented +2.

[jwren, 2014/03/11 21:53:04]

Done.

+      });
   }
 
   /// 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) {
         var severity = error.errorCode.errorSeverity;
         status = status.max(severity);
       }
     }
     return status;
   }
 
-  void prepareAnalysisContext(JavaFile sourceFile) {
+  void prepareAnalysisContext(JavaFile sourceFile, Source source) {
     List<UriResolver> resolvers = [new DartUriResolver(sdk), new FileUriResolver()];
     // may be add package resolver
     {
       JavaFile packageDirectory;
       if (options.packageRootPath != null) {
         packageDirectory = new JavaFile(options.packageRootPath);
       } else {
         packageDirectory = getPackageDirectoryFor(sourceFile);
       }
       if (packageDirectory != null) {
         resolvers.add(new PackageUriResolver([packageDirectory]));
       }
     }
     sourceFactory = new SourceFactory(resolvers);
     context = AnalysisEngine.instance.createAnalysisContext();
     context.sourceFactory = sourceFactory;
 
     // set options for context
     AnalysisOptionsImpl contextOptions = new AnalysisOptionsImpl();
     contextOptions.cacheSize = 256;
     contextOptions.hint = !options.disableHints;
     context.analysisOptions = contextOptions;
-  }
 
-  /// Fills [sources].
-  void prepareSources(LibraryElement library) {
-    var units = new Set<CompilationUnitElement>();
-    var libraries = new Set<LibraryElement>();
-    addLibrarySources(library, libraries, units);
+    // Create and add a ChangeSet
+    ChangeSet changeSet = new ChangeSet();
+    changeSet.addedSource(source);
+    context.applyChanges(changeSet);
   }
 
   void addCompilationUnitSource(CompilationUnitElement unit, Set<LibraryElement> libraries,
       Set<CompilationUnitElement> units) {
     if (unit == null || units.contains(unit)) {
       return;
     }
     units.add(unit);
     sources.add(unit.source);
   }
@@ skipping 22 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);
     }
   }
 
-  /// Fills [errorInfos].
+  /// Fills [errorInfos] using [sources].
   void prepareErrors() {
     for (Source source in sources) {
       context.computeErrors(source);
       var sourceErrors = context.getErrors(source);
       errorInfos.add(sourceErrors);
     }
   }
 
   static JavaFile getPackageDirectoryFor(JavaFile sourceFile) {
     // we are going to ask parent file, so get absolute path
@@ skipping 27 matching lines @@
         var internalPath = pathos.join(libraryDirectory, '_internal') + pathos.separator;
         if (!filePath.startsWith(internalPath)) {
           return UriKind.DART_URI;
         }
       }
     }
     // some generic file
     return UriKind.FILE_URI;
   }
 }