Use pub list-package-dirs in analyzer command line

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 'generated/constant.dart';
 import 'generated/engine.dart';
 import 'generated/element.dart';
 import 'generated/error.dart';
 import 'generated/java_io.dart';
-import 'generated/sdk.dart';
 import 'generated/sdk_io.dart';
 import 'generated/source_io.dart';
 import '../options.dart';
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/java_core.dart' show JavaSystem;
 import 'package:analyzer/src/error_formatter.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer/source/package_map_resolver.dart';
+import 'package:analyzer/source/package_map_provider.dart';
 
 /**
  * The maximum number of sources for which AST structures should be kept in the cache.
  */
 const int _MAX_CACHE_SIZE = 512;
 
-DartSdk sdk;
+DirectoryBasedDartSdk sdk;
 
 /// Analyzes single library [File].
 class AnalyzerImpl {
   final String sourcePath;
   final CommandLineOptions options;
   final int startTime;
 
   ContentCache contentCache = new ContentCache();
   SourceFactory sourceFactory;
   AnalysisContext context;
   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>();
+  final HashMap<Source, AnalysisErrorInfo> sourceErrorsMap =
+      new HashMap<Source, AnalysisErrorInfo>();
 
   AnalyzerImpl(this.sourcePath, this.options, this.startTime) {
     if (sdk == null) {
       sdk = new DirectoryBasedDartSdk(new JavaFile(options.dartSdkPath));
     }
   }
 
   /**
    * 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}) {
+  ErrorSeverity analyzeSync({int printMode: 1}) {
     setupForAnalysis();
     return _analyzeSync(printMode);
   }
 
   /**
    * Treats the [sourcePath] as the top level library and analyzes it using a
    * asynchronous algorithm over the analysis engine.
    */
   void analyzeAsync() {
     setupForAnalysis();
@@ skipping 57 matching lines @@
           sources.add(notice.source);
           sourceErrorsMap[notice.source] = notice;
         }
         return _analyzeAsync();
       }
       //
       // There are not any more tasks, set error code and print performance
       // numbers.
       //
       // prepare errors
-      sourceErrorsMap.forEach((k,v) {
+      sourceErrorsMap.forEach((k, v) {
         errorInfos.add(sourceErrorsMap[k]);
       });
 
       // print errors and performance numbers
       _printErrorsAndPerf();
 
       // compute max severity and set exitCode
       ErrorSeverity status = maxErrorSeverity;
       if (status == ErrorSeverity.WARNING && options.warningsAreFatal) {
         status = ErrorSeverity.ERROR;
       }
       exitCode = status.ordinal;
     }).catchError((ex, st) {
       AnalysisEngine.instance.logger.logError("${ex}\n${st}");
     });
   }
 
-  bool _excludeTodo(AnalysisError error) => error.errorCode.type != ErrorType.TODO;
+  bool _excludeTodo(AnalysisError error) =>
+      error.errorCode.type != ErrorType.TODO;
 
   _printErrorsAndPerf() {
     // The following is a hack. We currently print out to stderr to ensure that
     // when in batch mode we print to stderr, this is because the prints from
     // batch are made to stderr. The reason that options.shouldBatch isn't used
     // is because when the argument flags are constructed in BatchRunner and
     // passed in from batch mode which removes the batch flag to prevent the
     // "cannot have the batch flag and source file" error message.
     IOSink sink = options.machineFormat ? stderr : stdout;
 
@@ skipping 15 matching lines @@
       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");
-   }
+    }
   }
 
   _printColdPerf() {
     // print cold VM performance numbers
     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;
@@ skipping 18 matching lines @@
     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, Source source) {
-    List<UriResolver> resolvers = [new DartUriResolver(sdk), new FileUriResolver()];
+    List<UriResolver> resolvers = [
+        new DartUriResolver(sdk),
+        new FileUriResolver()];
     // may be add package resolver
     {
       JavaFile packageDirectory;
       if (options.packageRootPath != null) {
         packageDirectory = new JavaFile(options.packageRootPath);
+        resolvers.add(new PackageUriResolver([packageDirectory]));
+        stdout.write(

[Brian Wilkerson, 2014/09/09 20:30:43]

While it's nice to let users known about the change, there's a good chance that
printing this message will break some automated uses of the analyzer that have
expectations concerning the format of the output (especially if --machine was
specified. It might be better to move this message into the help message.

[jwren, 2014/09/09 20:36:17]

Done.

+            "The flag package-root is deprecated, by not including it on the command line a call will be made to pub to compute the package information.");

[Paul Berry, 2014/09/09 20:20:27]

This error message is confusing to me.  The phrase "by not including it on the
command line" seems to heavily imply that the user *didn't* include it on the
command line, but we only display the message if they did.

How about something like this instead?

"The flag package-root is deprecated.  Remove to use package information
computed by pub."

[jwren, 2014/09/09 20:36:17]

Done.

       } else {
-        packageDirectory = getPackageDirectoryFor(sourceFile);
-      }
-      if (packageDirectory != null) {
-        resolvers.add(new PackageUriResolver([packageDirectory]));
+        PubPackageMapProvider pubPackageMapProvider =
+            new PubPackageMapProvider(PhysicalResourceProvider.INSTANCE, sdk);
+        PackageMapInfo packageMapInfo = pubPackageMapProvider.computePackageMap(
+            PhysicalResourceProvider.INSTANCE.getResource(''));
+        resolvers.add(
+            new PackageMapUriResolver(
+                PhysicalResourceProvider.INSTANCE,
+                packageMapInfo.packageMap));
       }
     }
     sourceFactory = new SourceFactory(resolvers);
     context = AnalysisEngine.instance.createAnalysisContext();
     context.sourceFactory = sourceFactory;
     Map<String, String> definedVariables = options.definedVariables;
     if (!definedVariables.isEmpty) {
       DeclaredVariables declaredVariables = context.declaredVariables;
       definedVariables.forEach((String variableName, String value) {
         declaredVariables.define(variableName, value);
       });
     }
     // Uncomment the following to have errors reported on stdout and stderr
     AnalysisEngine.instance.logger = new StdLogger(options.log);
 
     // set options for context
     AnalysisOptionsImpl contextOptions = new AnalysisOptionsImpl();
     contextOptions.cacheSize = _MAX_CACHE_SIZE;
     contextOptions.hint = !options.disableHints;
     contextOptions.enableAsync = options.enableAsync;
     contextOptions.enableEnum = options.enableEnum;
     context.analysisOptions = contextOptions;
 
     // 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) {
+  void addCompilationUnitSource(CompilationUnitElement unit,
+      Set<LibraryElement> libraries, Set<CompilationUnitElement> units) {
     if (unit == null || units.contains(unit)) {
       return;
     }
     units.add(unit);
     sources.add(unit.source);
   }
 
   void addLibrarySources(LibraryElement library, Set<LibraryElement> libraries,
       Set<CompilationUnitElement> units) {
-    if (library == null || !libraries.add(library) ) {
+    if (library == null || !libraries.add(library)) {
       return;
     }
     // may be skip library
     {
       UriKind uriKind = library.source.uriKind;
       // Optionally skip package: libraries.
       if (!options.showPackageWarnings && uriKind == UriKind.PACKAGE_URI) {
         return;
       }
       // Optionally skip SDK libraries.
@@ skipping 92 matching lines @@
     }
   }
 
   @override
   void logInformation2(String message, Exception exception) {
     if (log) {
       stdout.writeln(message);
     }
   }
 }