Implement using AnalysisDriver in analyzer_cli. Disabled.

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/dart/analysis/driver.dart';
 import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/engine.dart' hide AnalysisResult;
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer_cli/src/driver.dart';
 import 'package:analyzer_cli/src/error_formatter.dart';
 import 'package:analyzer_cli/src/options.dart';
 import 'package:path/path.dart' as pathos;
 
 /// The maximum number of sources for which AST structures should be kept in the cache.
 const int _maxCacheSize = 512;
 
 int currentTimeMillis() => new DateTime.now().millisecondsSinceEpoch;
 
 /// 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;
+  final AnalysisDriver analysisDriver;
 
   /// 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.analysisOptions, this.context, this.librarySource,
-      this.options, this.stats, this.startTime);
+  AnalyzerImpl(this.analysisOptions, this.context, this.analysisDriver,
+      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 43 matching lines @@
   Future<ErrorSeverity> analyze({int printMode: 1}) async {
     setupForAnalysis();
     return await _analyze(printMode);
   }
 
   /// Fills [errorInfos] using [sources].
   Future<Null> prepareErrors() async {
     PerformanceTag previous = _prepareErrorsTag.makeCurrent();
     try {
       for (Source source in sources) {
-        context.computeErrors(source);
-        errorInfos.add(context.getErrors(source));
+        if (analysisDriver != null) {
+          String path = source.fullName;
+          AnalysisResult analysisResult = await analysisDriver.getResult(path);
+          errorInfos.add(new AnalysisErrorInfoImpl(
+              analysisResult.errors, analysisResult.lineInfo));
+        } else {
+          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>();
@@ skipping 11 matching lines @@
   }
 
   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;
     }
+
     LibraryElement libraryElement = await _resolveLibrary();
     prepareSources(libraryElement);
     await prepareErrors();
 
     // Print errors and performance numbers.
     if (printMode == 1) {
       _printErrors();
     } else if (printMode == 2) {
       _printColdPerf();
     }
@@ skipping 68 matching lines @@
         new ErrorFormatter(sink, options, stats, _processError);
     formatter.formatErrors(errorInfos);
   }
 
   ProcessedSeverity _processError(AnalysisError error) =>
       processError(error, options, analysisOptions);
 
   Future<LibraryElement> _resolveLibrary() async {
     PerformanceTag previous = _resolveLibraryTag.makeCurrent();
     try {
-      return context.computeLibraryElement(librarySource);
+      if (analysisDriver != null) {
+        String path = librarySource.fullName;
+        analysisDriver.priorityFiles = [path];
+        AnalysisResult analysisResult = await analysisDriver.getResult(path);
+        return analysisResult.unit.element.library;
+      } else {
+        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.
@@ skipping 99 matching lines @@
   }
 
   @override
   void logInformation(String message, [CaughtException exception]) {
     outSink.writeln(message);
     if (exception != null) {
       outSink.writeln(exception);
     }
   }
 }