Switch build mode to Analysis Driver.

pkg/analyzer_cli/lib/src/build_mode.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.build_mode;
 
 import 'dart:async';
 import 'dart:io' as io;
 
-import 'package:analyzer/dart/ast/ast.dart' show CompilationUnit;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/source/source_resource.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart' show SummaryBasedDartSdk;
-import 'package:analyzer/task/dart.dart';
 import 'package:analyzer_cli/src/driver.dart';
 import 'package:analyzer_cli/src/error_formatter.dart';
 import 'package:analyzer_cli/src/error_severity.dart';
 import 'package:analyzer_cli/src/options.dart';
 import 'package:bazel_worker/bazel_worker.dart';
+import 'package:front_end/src/base/performace_logger.dart';
+import 'package:front_end/src/byte_store/byte_store.dart';
 
 /**
  * Persistent Bazel worker.
  */
 class AnalyzerWorkerLoop extends AsyncWorkerLoop {
   final StringBuffer errorBuffer = new StringBuffer();
   final StringBuffer outBuffer = new StringBuffer();
 
   final ResourceProvider resourceProvider;
   final String dartSdkPath;
 
   AnalyzerWorkerLoop(this.resourceProvider, AsyncWorkerConnection connection,
       {this.dartSdkPath})
       : super(connection: connection);
 
   factory AnalyzerWorkerLoop.std(ResourceProvider resourceProvider,
       {io.Stdin stdinStream, io.Stdout stdoutStream, String dartSdkPath}) {
     AsyncWorkerConnection connection = new StdAsyncWorkerConnection(
         inputStream: stdinStream, outputStream: stdoutStream);
     return new AnalyzerWorkerLoop(resourceProvider, connection,
         dartSdkPath: dartSdkPath);
   }
 
   /**
    * Performs analysis with given [options].
    */
-  void analyze(CommandLineOptions options) {
-    new BuildMode(resourceProvider, options, new AnalysisStats()).analyze();
+  Future<Null> analyze(CommandLineOptions options) async {
+    var buildMode =
+        new BuildMode(resourceProvider, options, new AnalysisStats());
+    await buildMode.analyze();
     AnalysisEngine.instance.clearCaches();
   }
 
   /**
    * Perform a single loop step.
    */
   @override
   Future<WorkResponse> performRequest(WorkRequest request) async {
     errorBuffer.clear();
     outBuffer.clear();
     try {
       // Add in the dart-sdk argument if `dartSdkPath` is not null, otherwise it
       // will try to find the currently installed sdk.
       var arguments = new List<String>.from(request.arguments);
       if (dartSdkPath != null &&
           !arguments.any((arg) => arg.startsWith('--dart-sdk'))) {
         arguments.add('--dart-sdk=$dartSdkPath');
       }
       // Prepare options.
       CommandLineOptions options =
           CommandLineOptions.parse(arguments, printAndFail: (String msg) {
         throw new ArgumentError(msg);
       });
       // Analyze and respond.
-      analyze(options);
+      await analyze(options);
       String msg = _getErrorOutputBuffersText();
       return new WorkResponse()
         ..exitCode = EXIT_CODE_OK
         ..output = msg;
     } catch (e, st) {
       String msg = _getErrorOutputBuffersText();
       msg += '$e\n$st';
       return new WorkResponse()
         ..exitCode = EXIT_CODE_ERROR
         ..output = msg;
@@ skipping 27 matching lines @@
 
 /**
  * Analyzer used when the "--build-mode" option is supplied.
  */
 class BuildMode {
   final ResourceProvider resourceProvider;
   final CommandLineOptions options;
   final AnalysisStats stats;
 
   SummaryDataStore summaryDataStore;
-  InternalAnalysisContext context;
+  AnalysisOptions analysisOptions;
+  AnalysisDriver analysisDriver;
   Map<Uri, File> uriToFileMap;
   final List<Source> explicitSources = <Source>[];
   final List<PackageBundle> unlinkedBundles = <PackageBundle>[];
 
   PackageBundleAssembler assembler;
   final Set<Source> processedSources = new Set<Source>();
   final Map<String, UnlinkedUnit> uriToUnit = <String, UnlinkedUnit>{};
 
   BuildMode(this.resourceProvider, this.options, this.stats);
 
   bool get _shouldOutputSummary =>
       options.buildSummaryOutput != null ||
       options.buildSummaryOutputSemantic != null;
 
   /**
    * Perform package analysis according to the given [options].
    */
-  ErrorSeverity analyze() {
+  Future<ErrorSeverity> analyze() async {
     // Write initial progress message.
     if (!options.machineFormat) {
       outSink.writeln("Analyzing ${options.sourceFiles.join(', ')}...");
     }
 
     // Create the URI to file map.
     uriToFileMap = _createUriToFileMap(options.sourceFiles);
     if (uriToFileMap == null) {
       io.exitCode = ErrorSeverity.ERROR.ordinal;
       return ErrorSeverity.ERROR;
     }
 
     // BuildMode expects sourceFiles in the format "<uri>|<filepath>",
     // but the rest of the code base does not understand this format.
     // Rewrite sourceFiles, stripping the "<uri>|" prefix, so that it
     // does not cause problems with code that does not expect this format.
     options.rewriteSourceFiles(options.sourceFiles
         .map((String uriPipePath) =>
             uriPipePath.substring(uriPipePath.indexOf('|') + 1))
         .toList());
 
-    // Prepare the analysis context.
+    // Prepare the analysis driver.
     try {
-      _createContext();
+      _createAnalysisDriver();
     } on ConflictingSummaryException catch (e) {
       errorSink.writeln('$e');
       io.exitCode = ErrorSeverity.ERROR.ordinal;
       return ErrorSeverity.ERROR;
     }
 
     // Add sources.
-    ChangeSet changeSet = new ChangeSet();
     for (Uri uri in uriToFileMap.keys) {
       File file = uriToFileMap[uri];
       if (!file.exists) {
         errorSink.writeln('File not found: ${file.path}');
         io.exitCode = ErrorSeverity.ERROR.ordinal;
         return ErrorSeverity.ERROR;
       }
       Source source = new FileSource(file, uri);
       explicitSources.add(source);
-      changeSet.addedSource(source);
-    }
-    context.applyChanges(changeSet);
-
-    if (!options.buildSummaryOnly) {
-      // Perform full analysis.
-      while (true) {
-        AnalysisResult analysisResult = context.performAnalysisTask();
-        if (!analysisResult.hasMoreWork) {
-          break;
-        }
-      }
     }
 
     // Write summary.
     assembler = new PackageBundleAssembler();
     if (_shouldOutputSummary) {
       // Prepare all unlinked units.
       for (var src in explicitSources) {
-        _prepareUnlinkedUnit('${src.uri}');
+        await _prepareUnlinkedUnit('${src.uri}');
       }
 
       // Build and assemble linked libraries.
       if (!options.buildSummaryOnlyUnlinked) {
         // Prepare URIs of unlinked units that should be linked.
         var unlinkedUris = new Set<String>();
         for (var bundle in unlinkedBundles) {
           unlinkedUris.addAll(bundle.unlinkedUnitUris);
         }
         for (var src in explicitSources) {
@@ skipping 14 matching lines @@
         bundle.flushInformative();
         io.File file = new io.File(options.buildSummaryOutputSemantic);
         file.writeAsBytesSync(bundle.toBuffer(), mode: io.FileMode.WRITE_ONLY);
       }
     }
 
     if (options.buildSummaryOnly) {
       return ErrorSeverity.NONE;
     } else {
       // Process errors.
-      _printErrors(outputPath: options.buildAnalysisOutput);
-      return _computeMaxSeverity();
+      await _printErrors(outputPath: options.buildAnalysisOutput);
+      return await _computeMaxSeverity();
     }
   }
 
   /**
    * Compute linked libraries for the given [libraryUris] using the linked
    * libraries of the [summaryDataStore] and unlinked units in [uriToUnit], and
    * add them to  the [assembler].
    */
   void _computeLinkedLibraries(Set<String> libraryUris) {
     LinkedLibrary getDependency(String absoluteUri) =>
         summaryDataStore.linkedMap[absoluteUri];
 
     UnlinkedUnit getUnit(String absoluteUri) =>
         summaryDataStore.unlinkedMap[absoluteUri] ?? uriToUnit[absoluteUri];
 
     Map<String, LinkedLibraryBuilder> linkResult = link(
         libraryUris,
         getDependency,
         getUnit,
-        context.declaredVariables.get,
+        analysisDriver.declaredVariables.get,
         options.strongMode);
     linkResult.forEach(assembler.addLinkedLibrary);
   }
 
-  ErrorSeverity _computeMaxSeverity() {
+  Future<ErrorSeverity> _computeMaxSeverity() async {
     ErrorSeverity maxSeverity = ErrorSeverity.NONE;
     if (!options.buildSuppressExitCode) {
       for (Source source in explicitSources) {
-        AnalysisErrorInfo errorInfo = context.getErrors(source);
-        for (AnalysisError error in errorInfo.errors) {
+        ErrorsResult result = await analysisDriver.getErrors(source.fullName);
+        for (AnalysisError error in result.errors) {
           ErrorSeverity processedSeverity = determineProcessedSeverity(
-              error, options, context.analysisOptions);
+              error, options, analysisDriver.analysisOptions);
           if (processedSeverity != null) {
             maxSeverity = maxSeverity.max(processedSeverity);
           }
         }
       }
     }
     return maxSeverity;
   }
 
-  void _createContext() {
+  void _createAnalysisDriver() {
     // Read the summaries.
     summaryDataStore = new SummaryDataStore(<String>[],
         recordDependencyInfo: _shouldOutputSummary);
 
     // Adds a bundle at `path` to `summaryDataStore`.
     PackageBundle addBundle(String path) {
       var bundle =
           new PackageBundle.fromBuffer(new io.File(path).readAsBytesSync());
       summaryDataStore.addBundle(path, bundle);
       return bundle;
@@ skipping 35 matching lines @@
           Driver.createAnalysisOptionsForCommandLineOptions(
               resourceProvider, options);
       dartSdk.useSummary = !options.buildSummaryOnly;
       sdk = dartSdk;
       sdkBundle = dartSdk.getSummarySdkBundle(options.strongMode);
     }
 
     // Include SDK bundle to avoid parsing SDK sources.
     summaryDataStore.addBundle(null, sdkBundle);
 
-    // Create the context.
-    context = AnalysisEngine.instance.createAnalysisContext();
-    context.sourceFactory = new SourceFactory(<UriResolver>[
+    var sourceFactory = new SourceFactory(<UriResolver>[
       new DartUriResolver(sdk),
       new InSummaryUriResolver(resourceProvider, summaryDataStore),
       new ExplicitSourceResolver(uriToFileMap)
     ]);
 
-    // Set context options.
-    Driver.declareVariables(context.declaredVariables, options);
-    AnalysisOptionsImpl analysisOptions = Driver
-        .createAnalysisOptionsForCommandLineOptions(resourceProvider, options);
-    context.analysisOptions = analysisOptions;
+    analysisOptions = Driver.createAnalysisOptionsForCommandLineOptions(
+        resourceProvider, options);
 
-    if (!options.buildSummaryOnly) {
-      // Configure using summaries.
-      context.typeProvider = sdk.context.typeProvider;
-      context.resultProvider =
-          new InputPackagesResultProvider(context, summaryDataStore);
-    }
+    PerformanceLog logger = new PerformanceLog(null);
+    AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(logger);
+    analysisDriver = new AnalysisDriver(
+        scheduler,
+        logger,
+        resourceProvider,
+        new MemoryByteStore(),
+        new FileContentOverlay(),
+        null,
+        sourceFactory,
+        analysisOptions,
+        externalSummaries: summaryDataStore);
+    Driver.declareVariables(analysisDriver.declaredVariables, options);
+
+    scheduler.start();
   }
 
   /**
    * Convert [sourceEntities] (a list of file specifications of the form
    * "$uri|$path") to a map from URI to path.  If an error occurs, report the
    * error and return null.
    */
   Map<Uri, File> _createUriToFileMap(List<String> sourceEntities) {
     Map<Uri, File> uriToFileMap = <Uri, File>{};
     for (String sourceFile in sourceEntities) {
@@ skipping 11 matching lines @@
     return uriToFileMap;
   }
 
   /**
    * Ensure that the [UnlinkedUnit] for [absoluteUri] is available.
    *
    * If the unit is in the input [summaryDataStore], do nothing.
    *
    * Otherwise compute it and store into the [uriToUnit] and [assembler].
    */
-  void _prepareUnlinkedUnit(String absoluteUri) {
+  Future<Null> _prepareUnlinkedUnit(String absoluteUri) async {
     // Maybe an input package contains the source.
     if (summaryDataStore.unlinkedMap[absoluteUri] != null) {
       return;
     }
     // Parse the source and serialize its AST.
     Uri uri = Uri.parse(absoluteUri);
-    Source source = context.sourceFactory.forUri2(uri);
+    Source source = analysisDriver.sourceFactory.forUri2(uri);
     if (!source.exists()) {
       // TODO(paulberry): we should report a warning/error because DDC
       // compilations are unlikely to work.
       return;
     }
-    CompilationUnit unit = context.computeResult(source, PARSED_UNIT);
-    UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
+    var result = await analysisDriver.parseFile(source.fullName);
+    UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(result.unit);
     uriToUnit[absoluteUri] = unlinkedUnit;
     assembler.addUnlinkedUnit(source, unlinkedUnit);
   }
 
   /**
    * Print errors for all explicit sources.  If [outputPath] is supplied, output
    * is sent to a new file at that path.
    */
-  void _printErrors({String outputPath}) {
+  Future<Null> _printErrors({String outputPath}) async {
     StringBuffer buffer = new StringBuffer();
     var severityProcessor = (AnalysisError error) =>
-        determineProcessedSeverity(error, options, context.analysisOptions);
+        determineProcessedSeverity(error, options, analysisOptions);
     ErrorFormatter formatter = options.machineFormat
         ? new MachineErrorFormatter(buffer, options, stats,
             severityProcessor: severityProcessor)
         : new HumanErrorFormatter(buffer, options, stats,
             severityProcessor: severityProcessor);
     for (Source source in explicitSources) {
-      AnalysisErrorInfo errorInfo = context.getErrors(source);
+      var result = await analysisDriver.getErrors(source.fullName);
+      var errorInfo = new AnalysisErrorInfoImpl(result.errors, result.lineInfo);
       formatter.formatErrors([errorInfo]);
     }
     formatter.flush();
     if (!options.machineFormat) {
       stats.print(buffer);
     }
     if (outputPath == null) {
       StringSink sink = options.machineFormat ? errorSink : outSink;
       sink.write(buffer);
     } else {
@@ skipping 38 matching lines @@
    * Build the inverse mapping of [uriToSourceMap].
    */
   static Map<String, Uri> _computePathToUriMap(Map<Uri, File> uriToSourceMap) {
     Map<String, Uri> pathToUriMap = <String, Uri>{};
     uriToSourceMap.forEach((Uri uri, File file) {
       pathToUriMap[file.path] = uri;
     });
     return pathToUriMap;
   }
 }