Some improvements to the command-line analyzer's output.

pkg/analyzer_cli/lib/src/driver.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.driver;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io' as io;
 
@@ skipping 20 matching lines @@
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_general.dart'
     show PerformanceTag;
 import 'package:analyzer/src/lint/registry.dart';
 import 'package:analyzer/src/source/source_resource.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart' show SummaryBasedDartSdk;
 import 'package:analyzer/src/task/options.dart';
-import 'package:analyzer_cli/src/analyzer_impl.dart';
-import 'package:analyzer_cli/src/build_mode.dart';
-import 'package:analyzer_cli/src/error_formatter.dart';
-import 'package:analyzer_cli/src/options.dart';
-import 'package:analyzer_cli/src/perf_report.dart';
-import 'package:analyzer_cli/starter.dart';
 import 'package:linter/src/rules.dart' as linter;
 import 'package:package_config/discovery.dart' as pkg_discovery;
 import 'package:package_config/packages.dart' show Packages;
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as path;
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 import 'package:yaml/yaml.dart';
 
+import '../starter.dart' show CommandLineStarter;
+import 'analyzer_impl.dart';
+import 'build_mode.dart';
+import 'error_formatter.dart';
+import 'options.dart';
+import 'perf_report.dart';
+
 /// Shared IO sink for standard error reporting.
 ///
 /// *Visible for testing.*
 StringSink errorSink = io.stderr;
 
 /// Shared IO sink for standard out reporting.
 ///
 /// *Visible for testing.*
 StringSink outSink = io.stdout;
 
@@ skipping 85 matching lines @@
         io.exitCode = severity.ordinal;
       }
     }
 
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
     if (options.perfReport != null) {
       String json = makePerfReport(
-          startTime, currentTimeMillis(), options, _analyzedFileCount, stats);
+          startTime, currentTimeMillis, options, _analyzedFileCount, stats);
       new io.File(options.perfReport).writeAsStringSync(json);
     }
   }
 
   Future<ErrorSeverity> _analyzeAll(CommandLineOptions options) async {
     PerformanceTag previous = _analyzeAllTag.makeCurrent();
     try {
       return await _analyzeAllImpl(options);
     } finally {
       previous.makeCurrent();
     }
   }
 
   /// Perform analysis according to the given [options].
   Future<ErrorSeverity> _analyzeAllImpl(CommandLineOptions options) async {
     if (!options.machineFormat) {
-      outSink.writeln("Analyzing ${options.sourceFiles}...");
+      List<String> fileNames = options.sourceFiles.map((String file) {
+        file = path.normalize(file);
+        if (file == '.') {
+          file = path.basename(path.current);
+        } else if (file == '..') {
+          file = path.basename(path.normalize(path.absolute(file)));
+        }
+        return file;
+      }).toList();
+
+      outSink.writeln("Analyzing ${fileNames.join(', ')}...");
     }
 
     // Create a context, or re-use the previous one.
     try {
       _createAnalysisContext(options);
     } on _DriverError catch (error) {
       outSink.writeln(error.msg);
       return ErrorSeverity.ERROR;
     }
 
-    // Add all the files to be analyzed en masse to the context.  Skip any
+    // Add all the files to be analyzed en masse to the context. Skip any
     // files that were added earlier (whether explicitly or implicitly) to
     // avoid causing those files to be unnecessarily re-read.
     Set<Source> knownSources = context.sources.toSet();
-    List<Source> sourcesToAnalyze = <Source>[];
+    Set<Source> sourcesToAnalyze = new Set<Source>();
     ChangeSet changeSet = new ChangeSet();
     for (String sourcePath in options.sourceFiles) {
       sourcePath = sourcePath.trim();
 
       // Collect files for analysis.
       // Note that these files will all be analyzed in the same context.
       // This should be updated when the ContextManager re-work is complete
       // (See: https://github.com/dart-lang/sdk/issues/24133)
       Iterable<io.File> files = _collectFiles(sourcePath);
       if (files.isEmpty) {
         errorSink.writeln('No dart files found at: $sourcePath');
         io.exitCode = ErrorSeverity.ERROR.ordinal;
         return ErrorSeverity.ERROR;
       }
 
       for (io.File file in files) {
         Source source = _computeLibrarySource(file.absolute.path);
         if (!knownSources.contains(source)) {
           changeSet.addedSource(source);
         }
         sourcesToAnalyze.add(source);
       }
 
-      if (analysisDriver != null) {
-        files.forEach((file) {
-          analysisDriver.addFile(file.path);
-        });
-      } else {
-        context.applyChanges(changeSet);
-      }
+      files.forEach((file) {

[Brian Wilkerson, 2017/02/19 22:52:17]

It looks like this CL is also removing the non-driver path. Is that intentional?

[devoncarew, 2017/02/21 04:30:47]

No - it's unintentional. I had a fair amount of changes to try and fix the
duplicate analysis issues bug; looks like those changes didn't get completely
backed out.

+        analysisDriver.addFile(file.path);
+      });
     }
 
     // Analyze the libraries.
     ErrorSeverity allResult = ErrorSeverity.NONE;
-    var libUris = <Uri>[];
-    var parts = <Source>[];
+    List<Uri> libUris = <Uri>[];
+    Set<Source> partSources = new Set<Source>();
+
     for (Source source in sourcesToAnalyze) {
       SourceKind sourceKind = analysisDriver != null
           ? await analysisDriver.getSourceKind(source.fullName)
           : context.computeKindOf(source);
       if (sourceKind == SourceKind.PART) {
-        parts.add(source);
+        partSources.add(source);
         continue;
       }
+      // TODO(devoncarew): Analyzing each source individually causes errors to
+      // be reported multiple times (#25697).
       ErrorSeverity status = await _runAnalyzer(source, options);
       allResult = allResult.max(status);
       libUris.add(source.uri);
     }
 
     // Check that each part has a corresponding source in the input list.
-    for (Source part in parts) {
+    for (Source partSource in partSources) {
       bool found = false;
       if (analysisDriver != null) {
-        var partFile = analysisDriver.fsState.getFileForPath(part.fullName);
+        var partFile =
+            analysisDriver.fsState.getFileForPath(partSource.fullName);
         if (libUris.contains(partFile.library?.uri)) {
           found = true;
         }
       } else {
-        for (var lib in context.getLibrariesContaining(part)) {
+        for (var lib in context.getLibrariesContaining(partSource)) {
           if (libUris.contains(lib.uri)) {
             found = true;
           }
         }
       }
       if (!found) {
-        errorSink.writeln("${part.fullName} is a part and cannot be analyzed.");
+        errorSink.writeln(
+            "${partSource.fullName} is a part and cannot be analyzed.");
         errorSink.writeln("Please pass in a library that contains this part.");
         io.exitCode = ErrorSeverity.ERROR.ordinal;
         allResult = allResult.max(ErrorSeverity.ERROR);
       }
     }
 
     if (!options.machineFormat) {
       stats.print(outSink);
     }
 
@@ skipping 190 matching lines @@
     if (packageUriResolver != null) {
       resolvers.add(packageUriResolver);
     }
 
     // Finally files.
     resolvers.add(new file_system.ResourceUriResolver(resourceProvider));
 
     return new SourceFactory(resolvers, packageInfo.packages);
   }
 
+  // TODO(devoncarew): This needs to respect analysis_options excludes.
+
   /// Collect all analyzable files at [filePath], recursively if it's a
   /// directory, ignoring links.
   Iterable<io.File> _collectFiles(String filePath) {
     List<io.File> files = <io.File>[];
     io.File file = new io.File(filePath);
     if (file.existsSync()) {
       files.add(file);
     } else {
       io.Directory directory = new io.Directory(filePath);
       if (directory.existsSync()) {
@@ skipping 200 matching lines @@
 
     ExtensionManager manager = new ExtensionManager();
     manager.processPlugins(plugins);
 
     linter.registerLintRules();
   }
 
   /// Analyze a single source.
   Future<ErrorSeverity> _runAnalyzer(
       Source source, CommandLineOptions options) async {
-    int startTime = currentTimeMillis();
+    int startTime = currentTimeMillis;
     AnalyzerImpl analyzer = new AnalyzerImpl(_context.analysisOptions, _context,
         analysisDriver, source, options, stats, startTime);
     ErrorSeverity errorSeverity = await analyzer.analyze();
     if (errorSeverity == ErrorSeverity.ERROR) {
       io.exitCode = errorSeverity.ordinal;
     }
     if (options.warningsAreFatal && errorSeverity == ErrorSeverity.WARNING) {
       io.exitCode = errorSeverity.ordinal;
     }
     return errorSeverity;
@@ skipping 243 matching lines @@
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }