add --x-package-warnings-prefix option to dartanalyzer

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';
 
@@ skipping 62 matching lines @@
   /// The plugins that are defined outside the `analyzer_cli` package.
   List<Plugin> _userDefinedPlugins = <Plugin>[];
 
   /// Indicates whether the analyzer is running in batch mode.
   bool _isBatch;
 
   /// The context that was most recently created by a call to [_analyzeAll], or
   /// `null` if [_analyzeAll] hasn't been called yet.
   AnalysisContext _context;
 
+  /// The total number of source files loaded by an AnalysisContext.
+  int _analyzedFileCount = 0;
+
   /// If [_context] is not `null`, the [CommandLineOptions] that guided its
   /// creation.
   CommandLineOptions _previousOptions;
 
   @override
   EmbeddedResolverProvider embeddedUriResolverProvider;
 
   @override
   ResolverProvider packageResolverProvider;
 
   /// Collected analysis statistics.
   final AnalysisStats stats = new AnalysisStats();
 
   /// This Driver's current analysis context.
   ///
   /// *Visible for testing.*
   AnalysisContext get context => _context;
 
   @override
   void set userDefinedPlugins(List<Plugin> plugins) {
     _userDefinedPlugins = plugins ?? <Plugin>[];
   }
 
   @override
   void start(List<String> args) {
+    if (_context != null) {
+      throw new StateError("start() can only be called once");
+    }
     int startTime = new DateTime.now().millisecondsSinceEpoch;
 
     StringUtilities.INTERNER = new MappedInterner();
 
     _processPlugins();
 
     // Parse commandline options.
     CommandLineOptions options = CommandLineOptions.parse(args);
 
     // Cache options of interest to inform analysis.
@@ skipping 12 matching lines @@
         return _analyzeAll(options);
       });
     } else {
       ErrorSeverity severity = _analyzeAll(options);
       // In case of error propagate exit code.
       if (severity == ErrorSeverity.ERROR) {
         exitCode = severity.ordinal;
       }
     }
 
+    if (_context != null) {
+      _analyzedFileCount += _context.sources.length;
+    }
+
     if (options.perfReport != null) {
-      String json = makePerfReport(startTime, currentTimeMillis(), options);
+      String json = makePerfReport(
+          startTime, currentTimeMillis(), options, _analyzedFileCount, stats);
       new File(options.perfReport).writeAsStringSync(json);
     }
   }
 
   ErrorSeverity _analyzeAll(CommandLineOptions options) {
     return _analyzeAllTag.makeCurrentWhile(() {
       return _analyzeAllImpl(options);
     });
   }
 
@@ skipping 108 matching lines @@
     if (options.disableHints != _previousOptions.disableHints) {
       return false;
     }
     if (options.enableStrictCallChecks !=
         _previousOptions.enableStrictCallChecks) {
       return false;
     }
     if (options.showPackageWarnings != _previousOptions.showPackageWarnings) {
       return false;
     }
+    if (options.showPackageWarningsPrefix !=
+        _previousOptions.showPackageWarningsPrefix) {
+      return false;
+    }
     if (options.showSdkWarnings != _previousOptions.showSdkWarnings) {
       return false;
     }
     if (options.lints != _previousOptions.lints) {
       return false;
     }
     if (options.strongMode != _previousOptions.strongMode) {
       return false;
     }
     if (options.enableSuperMixins != _previousOptions.enableSuperMixins) {
@@ skipping 13 matching lines @@
       CommandLineOptions options) {
     if (_isBatch) {
       // As analyzer is currently implemented, once a file has been diet
       // parsed, it can't easily be un-diet parsed without creating a brand new
       // context and losing caching.  In batch mode, we can't predict which
       // files we'll need to generate errors and warnings for in the future, so
       // we can't safely diet parse anything.
       return (Source source) => true;
     }
 
-    // Determine the set of packages requiring a full parse.  Use null to
-    // represent the case where all packages require a full parse.
-    Set<String> packagesRequiringFullParse;
-    if (options.showPackageWarnings) {
-      // We are showing warnings from all packages so all packages require a
-      // full parse.
-      packagesRequiringFullParse = null;
-    } else {
-      // We aren't showing warnings for dependent packages, but we may still
-      // need to show warnings for "self" packages, so we need to do a full
-      // parse in any package containing files mentioned on the command line.
-      // TODO(paulberry): implement this.  As a temporary workaround, we're
-      // fully parsing all packages.
-      packagesRequiringFullParse = null;
-    }
     return (Source source) {
       if (options.sourceFiles.contains(source.fullName)) {
         return true;
       } else if (source.uri.scheme == 'dart') {
         return options.showSdkWarnings;
-      } else if (source.uri.scheme == 'package') {
-        if (packagesRequiringFullParse == null) {
-          return true;
-        } else if (source.uri.pathSegments.length == 0) {
-          // We should never see a URI like this, but fully parse it to be
-          // safe.
-          return true;
-        } else {
-          return packagesRequiringFullParse
-              .contains(source.uri.pathSegments[0]);
-        }
       } else {
+        // TODO(paulberry): diet parse 'package:' imports when we don't want
+        // diagnostics. (Full parse is still needed for "self" packages.)
         return true;
       }
     };
   }
 
   /// Decide on the appropriate method for resolving URIs based on the given
   /// [options] and [customUrlMappings] settings, and return a
   /// [SourceFactory] that has been configured accordingly.
   SourceFactory _chooseUriResolutionPolicy(
       CommandLineOptions options, EmbedderYamlLocator yamlLocator) {
@@ skipping 156 matching lines @@
   }
 
   /// Create an analysis context that is prepared to analyze sources according
   /// to the given [options], and store it in [_context].
   void _createAnalysisContext(CommandLineOptions options) {
     if (_canContextBeReused(options)) {
       return;
     }
     _previousOptions = options;
 
+    // Save stats from previous context before clobbering it.
+    if (_context != null) {
+      _analyzedFileCount += _context.sources.length;
+    }
+
     // Create a context.
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
-    _context = context;
+    _context = AnalysisEngine.instance.createAnalysisContext();
 
     // Choose a package resolution policy and a diet parsing policy based on
     // the command-line options.
     SourceFactory sourceFactory = _chooseUriResolutionPolicy(
-        options, (context as InternalAnalysisContext).embedderYamlLocator);
+        options, (_context as InternalAnalysisContext).embedderYamlLocator);
     AnalyzeFunctionBodiesPredicate dietParsingPolicy =
         _chooseDietParsingPolicy(options);
 
-    context.sourceFactory = sourceFactory;
+    _context.sourceFactory = sourceFactory;
 
     setAnalysisContextOptions(_context, options,
         (AnalysisOptionsImpl contextOptions) {
       contextOptions.analyzeFunctionBodiesPredicate = dietParsingPolicy;
     });
   }
 
   /// Return discovered packagespec, or `null` if none is found.
   Packages _discoverPackagespec(Uri root) {
     try {
@@ skipping 244 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;
   }
 }