Cache AnalysisOptionsImpl objects for context directories.

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.
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart' as file_system;
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 53 matching lines @@
 /// Test this option map to see if it specifies lint rules.
 bool containsLintRuleEntry(Map<String, YamlNode> options) {
   var linterNode = options['linter'];
   return linterNode is YamlMap && linterNode.containsKey('rules');
 }
 
 class Driver implements CommandLineStarter {
   static final PerformanceTag _analyzeAllTag =
       new PerformanceTag("Driver._analyzeAll");
 
+  /// Cache of [AnalysisOptionsImpl] objects that correspond to directories
+  /// with analyzed files, used to reduce searching for `analysis_options.yaml`
+  /// files.
+  static Map<String, AnalysisOptionsImpl> _directoryToAnalysisOptions = {};
+
   static ByteStore analysisDriverMemoryByteStore = new MemoryByteStore();
 
   /// The plugins that are defined outside the `analyzer_cli` package.
   List<Plugin> _userDefinedPlugins = <Plugin>[];
 
   /// The context that was most recently created by a call to [_analyzeAll], or
   /// `null` if [_analyzeAll] hasn't been called yet.
   InternalAnalysisContext _context;
 
   AnalysisDriver analysisDriver;
@@ skipping 220 matching lines @@
       if (options.buildModePersistentWorker) {
         new AnalyzerWorkerLoop.std(resourceProvider,
                 dartSdkPath: options.dartSdkPath)
             .run();
       } else {
         return new BuildMode(resourceProvider, options, stats).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, AnalysisOptionsImpl other) {
-    // TODO(paulberry): add a command-line option that disables context re-use.
-    if (_context == null) {
-      return false;
-    }
-
-    // Check command line options.
-    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.enableAssertInitializer !=
-        _previousOptions.enableAssertInitializer) {
-      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) {
-      return false;
-    }
-    if (!_equalLists(
-        options.buildSummaryInputs, _previousOptions.buildSummaryInputs)) {
-      return false;
-    }
-    if (options.disableCacheFlushing != _previousOptions.disableCacheFlushing) {
-      return false;
-    }
-
-    // Check analysis options.
-    var c = _context.analysisOptions;
-    if (!(other.enableAssertInitializer == c.enableAssertInitializer &&
-        other.enableStrictCallChecks == c.enableStrictCallChecks &&
-        other.enableLazyAssignmentOperators ==
-            c.enableLazyAssignmentOperators &&
-        other.enableSuperMixins == c.enableSuperMixins &&
-        other.enableTiming == c.enableTiming &&
-        other.generateImplicitErrors == c.generateImplicitErrors &&
-        other.generateSdkErrors == c.generateSdkErrors &&
-        other.hint == c.hint &&
-        other.lint == c.lint &&
-        AnalysisOptionsImpl.compareLints(other.lintRules, c.lintRules) &&
-        other.preserveComments == c.preserveComments &&
-        other.strongMode == c.strongMode)) {
-      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 (options.shouldBatch) {
       // 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
@@ skipping 108 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()) {
         for (io.FileSystemEntity entry
             in directory.listSync(recursive: true, followLinks: false)) {
           String relative = path.relative(entry.path, from: directory.path);
           if (AnalysisEngine.isDartFileName(entry.path) &&
               !_isInHiddenDir(relative)) {
             files.add(entry);
           }
         }
       }
     }
     return files;
   }
 
+  // TODO(devoncarew): This needs to respect analysis_options excludes.

[Brian Wilkerson, 2017/06/27 19:11:02]

The comment moved. I'm not sure what it was suppose to be associated with, but
assuming it was correct before, perhaps we could move it inside the
_collectFiles method.

+
   /// Convert the given [sourcePath] (which may be relative to the current
   /// working directory) to a [Source] object that can be fed to the analysis
   /// context.
   Source _computeLibrarySource(String sourcePath) {
     sourcePath = _normalizeSourcePath(sourcePath);
     File sourceFile = resourceProvider.getFile(sourcePath);
     Source source = sdk.fromFileUri(sourceFile.toUri());
     if (source != null) {
       return source;
     }
     source = new FileSource(sourceFile, sourceFile.toUri());
     Uri uri = _context.sourceFactory.restoreUri(source);
     if (uri == null) {
       return source;
     }
     return new FileSource(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 not the same command-line options, clear cached information.
+    if (!_equalCommandLineOptions(_previousOptions, options)) {
+      _previousOptions = options;
+      _directoryToAnalysisOptions.clear();
+      _context = null;
+      analysisDriver = null;
+    }
+
     AnalysisOptionsImpl analysisOptions =
         createAnalysisOptionsForCommandLineOptions(resourceProvider, options);
     analysisOptions.analyzeFunctionBodiesPredicate =
         _chooseDietParsingPolicy(options);
 
-    if (_canContextBeReused(options, analysisOptions)) {
+    // If we have the analysis driver, and the new analysis options are the
+    // same, we can reuse this analysis driver.
+    if (_context != null &&
+        _equalAnalysisOptions(_context.analysisOptions, analysisOptions)) {
       return;
     }
 
-    _previousOptions = options;
-
     // Save stats from previous context before clobbering it.
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
     // Find package info.
     _PackageInfo packageInfo = _findPackages(options);
 
     // Process embedders.
     Map<file_system.Folder, YamlMap> embedderMap =
@@ skipping 62 matching lines @@
       if (packages != Packages.noPackages) {
         return packages;
       }
     } catch (_) {
       // Ignore and fall through to null.
     }
 
     return null;
   }
 
+  /// Return whether [a] and [b] options are equal for the purpose of
+  /// command line analysis.
+  bool _equalAnalysisOptions(AnalysisOptionsImpl a, AnalysisOptions b) {
+    return a.enableAssertInitializer == b.enableAssertInitializer &&
+        a.enableStrictCallChecks == b.enableStrictCallChecks &&
+        a.enableLazyAssignmentOperators == b.enableLazyAssignmentOperators &&
+        a.enableSuperMixins == b.enableSuperMixins &&
+        a.enableTiming == b.enableTiming &&
+        a.generateImplicitErrors == b.generateImplicitErrors &&
+        a.generateSdkErrors == b.generateSdkErrors &&
+        a.hint == b.hint &&
+        a.lint == b.lint &&
+        AnalysisOptionsImpl.compareLints(a.lintRules, b.lintRules) &&
+        a.preserveComments == b.preserveComments &&
+        a.strongMode == b.strongMode;
+  }
+
   _PackageInfo _findPackages(CommandLineOptions options) {
     if (packageResolverProvider != null) {
       // The resolver provider will do all the work later.
       return new _PackageInfo(null, null);
     }
 
     Packages packages;
     Map<String, List<file_system.Folder>> packageMap;
 
     if (options.packageConfigPath != null) {
@@ skipping 125 matching lines @@
       contextRoot = options.sourceFiles[0];
       if (!path.isAbsolute(contextRoot)) {
         contextRoot = path.absolute(contextRoot);
       }
     }
 
     void verbosePrint(String text) {
       outSink.writeln(text);
     }
 
-    AnalysisOptionsImpl contextOptions = new ContextBuilder(
-            resourceProvider, null, null,
+    // Prepare the directory which is, or contains, the context root.
+    String contextRootDirectory;
+    if (resourceProvider.getFolder(contextRoot).exists) {
+      contextRootDirectory = contextRoot;
+    } else {
+      contextRootDirectory = resourceProvider.pathContext.dirname(contextRoot);
+    }
+
+    // Check if there is the options object for the content directory.
+    AnalysisOptionsImpl contextOptions =
+        _directoryToAnalysisOptions[contextRootDirectory];
+    if (contextOptions != null) {
+      return contextOptions;
+    }
+
+    contextOptions = new ContextBuilder(resourceProvider, null, null,
             options: options.contextBuilderOptions)
         .getAnalysisOptions(contextRoot,
             verbosePrint: options.verbose ? verbosePrint : null);
 
     contextOptions.trackCacheDependencies = false;
     contextOptions.disableCacheFlushing = options.disableCacheFlushing;
     contextOptions.hint = !options.disableHints;
     contextOptions.generateImplicitErrors = options.showPackageWarnings;
     contextOptions.generateSdkErrors = options.showSdkWarnings;
     if (options.enableAssertInitializer != null) {
       contextOptions.enableAssertInitializer = options.enableAssertInitializer;
     }
 
+    _directoryToAnalysisOptions[contextRootDirectory] = contextOptions;
     return contextOptions;
   }
 
   static void setAnalysisContextOptions(
       file_system.ResourceProvider resourceProvider,
       AnalysisContext context,
       CommandLineOptions options,
       void configureContextOptions(AnalysisOptionsImpl contextOptions)) {
     AnalysisOptionsImpl analysisOptions =
         createAnalysisOptionsForCommandLineOptions(resourceProvider, options);
@@ skipping 12 matching lines @@
     }
 
     if (options.log) {
       AnalysisEngine.instance.logger = new StdLogger();
     }
 
     // Set context options.
     context.analysisOptions = analysisOptions;
   }
 
+  /// Return whether the [newOptions] are equal to the [previous].
+  static bool _equalCommandLineOptions(
+      CommandLineOptions previous, CommandLineOptions newOptions) {
+    if (previous == null || newOptions == null) {
+      return false;
+    }
+    if (newOptions.packageRootPath != previous.packageRootPath) {
+      return false;
+    }
+    if (newOptions.packageConfigPath != previous.packageConfigPath) {
+      return false;
+    }
+    if (!_equalMaps(newOptions.definedVariables, previous.definedVariables)) {
+      return false;
+    }
+    if (newOptions.log != previous.log) {
+      return false;
+    }
+    if (newOptions.disableHints != previous.disableHints) {
+      return false;
+    }
+    if (newOptions.enableStrictCallChecks != previous.enableStrictCallChecks) {
+      return false;
+    }
+    if (newOptions.enableAssertInitializer !=
+        previous.enableAssertInitializer) {
+      return false;
+    }
+    if (newOptions.showPackageWarnings != previous.showPackageWarnings) {
+      return false;
+    }
+    if (newOptions.showPackageWarningsPrefix !=
+        previous.showPackageWarningsPrefix) {
+      return false;
+    }
+    if (newOptions.showSdkWarnings != previous.showSdkWarnings) {
+      return false;
+    }
+    if (newOptions.lints != previous.lints) {
+      return false;
+    }
+    if (newOptions.strongMode != previous.strongMode) {
+      return false;
+    }
+    if (newOptions.enableSuperMixins != previous.enableSuperMixins) {
+      return false;
+    }
+    if (!_equalLists(
+        newOptions.buildSummaryInputs, previous.buildSummaryInputs)) {
+      return false;
+    }
+    if (newOptions.disableCacheFlushing != previous.disableCacheFlushing) {
+      return false;
+    }
+    return true;
+  }
+
   /// Perform a deep comparison of two string lists.
   static bool _equalLists(List<String> l1, List<String> l2) {
     if (l1.length != l2.length) {
       return false;
     }
     for (int i = 0; i < l1.length; i++) {
       if (l1[i] != l2[i]) {
         return false;
       }
     }
@@ skipping 47 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;
   }
 }