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 61 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;
 
-  /// If [_context] is not `null`, the [CommandLineOptions] that guided its
-  /// creation.
-  CommandLineOptions _previousOptions;
-
   @override
   EmbeddedResolverProvider embeddedUriResolverProvider;
 
   @override
   ResolverProvider packageResolverProvider;
 
   /// This Driver's current analysis context.
   ///
   /// *Visible for testing.*
   AnalysisContext get context => _context;
 
   @override
   void set userDefinedPlugins(List<Plugin> plugins) {
     _userDefinedPlugins = plugins == null ? <Plugin>[] : plugins;
   }
 
   @override
   void start(List<String> args) {
+    if (_context != null) {
+      throw new StateError("start() can only be called once");

[Brian Wilkerson, 2016/03/18 14:13:17]

Start *is* only called once, and it seems unlikely that anyone would make the
mistake of calling it again, so I don't understand the value of this check.

[skybrian, 2016/03/18 22:32:44]

It's to make it easier for the next reader to tell that _analyzedFileCount is
calculated correctly.

Otherwise someone reading this code for the first time needs to look at the
usages to make sure that start() is indeed called only once. Since I did that
already, I thought it would be helpful to state the invariant explicitly.

In general, I think enforcing the invariants that you rely on makes code easier
to review. (Something I picked up from design by contract.)

+    }
     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 13 matching lines @@
       });
     } else {
       ErrorSeverity severity = _analyzeAll(options);
       // In case of error propagate exit code.
       if (severity == ErrorSeverity.ERROR) {
         exitCode = severity.ordinal;
       }
     }
 
     if (options.perfReport != null) {
-      String json = makePerfReport(startTime, currentTimeMillis(), options);
+      String json =
+          makePerfReport(startTime, currentTimeMillis(), options, _context);
       new File(options.perfReport).writeAsStringSync(json);
     }
   }
 
   ErrorSeverity _analyzeAll(CommandLineOptions options) {
     return _analyzeAllTag.makeCurrentWhile(() {
       return _analyzeAllImpl(options);
     });
   }
 
@@ skipping 74 matching lines @@
     return allResult;
   }
 
   /// Perform package analysis according to the given [options].
   ErrorSeverity _analyzePackage(CommandLineOptions options) {
     return _analyzeAllTag.makeCurrentWhile(() {
       return new PackageAnalyzer(options).analyze();
     });
   }
 
-  /// Determine whether the context created during a previous call to
-  /// [_analyzeAll] can be re-used in order to analyze using [options].
-  bool _canContextBeReused(CommandLineOptions options) {
-    // TODO(paulberry): add a command-line option that disables context re-use.
-    if (_context == null) {
-      return false;
-    }
-    if (options.packageRootPath != _previousOptions.packageRootPath) {
-      return false;
-    }
-    if (options.packageConfigPath != _previousOptions.packageConfigPath) {
-      return false;
-    }
-    if (!_equalMaps(
-        options.definedVariables, _previousOptions.definedVariables)) {
-      return false;
-    }
-    if (options.log != _previousOptions.log) {
-      return false;
-    }
-    if (options.disableHints != _previousOptions.disableHints) {
-      return false;
-    }
-    if (options.enableStrictCallChecks !=
-        _previousOptions.enableStrictCallChecks) {
-      return false;
-    }
-    if (options.showPackageWarnings != _previousOptions.showPackageWarnings) {
-      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) {
-      return false;
-    }
-    if (options.enableConditionalDirectives !=
-        _previousOptions.enableConditionalDirectives) {
-      return false;
-    }
-    return true;
-  }
-
   /// Decide on the appropriate policy for which files need to be fully parsed
   /// and which files need to be diet parsed, based on [options], and return an
   /// [AnalyzeFunctionBodiesPredicate] that implements this policy.
   AnalyzeFunctionBodiesPredicate _chooseDietParsingPolicy(
       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 where 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 128 matching lines @@
     Uri uri = _context.sourceFactory.restoreUri(source);
     if (uri == null) {
       return source;
     }
     return new FileBasedSource(sourceFile, uri);
   }
 
   /// 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;
-
-    // Create a context.
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
-    _context = context;
+    assert(_context == null);
+    _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 90 matching lines @@
     configureContextOptions(contextOptions);
 
     // Set context options.
     context.analysisOptions = contextOptions;
     context.sourceFactory.dartSdk.context.analysisOptions = contextOptions;
 
     // Process analysis options file (and notify all interested parties).
     _processAnalysisOptions(context, options);
   }
 
-  /// Perform a deep comparison of two string maps.
-  static bool _equalMaps(Map<String, String> m1, Map<String, String> m2) {
-    if (m1.length != m2.length) {
-      return false;
-    }
-    for (String key in m1.keys) {
-      if (!m2.containsKey(key) || m1[key] != m2[key]) {
-        return false;
-      }
-    }
-    return true;
-  }
-
   static fileSystem.File _getOptionsFile(CommandLineOptions options) {
     fileSystem.File file;
     String filePath = options.analysisOptionsFile;
     if (filePath != null) {
       file = PhysicalResourceProvider.INSTANCE.getFile(filePath);
       if (!file.exists) {
         printAndFail('Options file not found: $filePath',
             exitCode: ErrorSeverity.ERROR.ordinal);
       }
     } else {
@@ skipping 117 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;
   }
 }