Avoid redundant calls to "pub list" when multiple dependencies change.

pkg/analysis_server/lib/src/context_manager.dart

 // Copyright (c) 2014, 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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/analysis_server.dart';
+import 'package:analysis_server/src/source/optimizing_pub_package_map_provider.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
-import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 
 /**
  * The name of `packages` folders.
@@ skipping 51 matching lines @@
   /**
    * Same as [packageRoots], except that source folders have been normalized
    * and non-folders have been removed.
    */
   Map<String, String> normalizedPackageRoots = <String, String>{};
 
   /**
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
-  final PackageMapProvider _packageMapProvider;
+  final OptimizingPubPackageMapProvider _packageMapProvider;
 
   /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
   ContextManager(this.resourceProvider, this._packageMapProvider,
       this._instrumentationService) {
     pathContext = resourceProvider.pathContext;
   }
@@ skipping 34 matching lines @@
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
   /**
+   * Return a list containing all of the contexts contained in the given
+   * [analysisRoot].
+   */
+  List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
+    List<AnalysisContext> contexts = <AnalysisContext>[];
+    _contexts.forEach((Folder contextFolder, _ContextInfo info) {
+      if (analysisRoot.isOrContains(contextFolder.path)) {
+        contexts.add(info.context);
+      }
+    });
+    return contexts;
+  }
+
+  /**
    * We have finished computing the package map.
    */
   void endComputePackageMap() {
     // Do nothing.
   }
 
   /**
    * Returns `true` if the given absolute [path] is in one of the current
    * root folders and is not excluded.
    */
   bool isInAnalysisRoot(String path) {
     // check if excluded
     if (_isExcluded(path)) {
       return false;
     }
     // check if in of the roots
     for (Folder root in _contexts.keys) {
       if (root.contains(path)) {
         return true;
       }
     }
     // no
     return false;
   }
 
   /**
-   * Return a list containing all of the contexts contained in the given
-   * [analysisRoot].
-   */
-  List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
-    List<AnalysisContext> contexts = <AnalysisContext>[];
-    _contexts.forEach((Folder contextFolder, _ContextInfo info) {
-      if (analysisRoot.isOrContains(contextFolder.path)) {
-        contexts.add(info.context);
-      }
-    });
-    return contexts;
-  }
-
-  /**
    * Rebuild the set of contexts from scratch based on the data last sent to
    * setRoots(). Only contexts contained in the given list of analysis [roots]
    * will be rebuilt, unless the list is `null`, in which case every context
    * will be rebuilt.
    */
   void refresh(List<Resource> roots) {
     // Destroy old contexts
     List<Folder> contextFolders = _contexts.keys.toList();
     if (roots == null) {
       contextFolders.forEach(_destroyContext);
@@ skipping 191 matching lines @@
     }
   }
 
   /**
    * Compute the appropriate package URI resolver for [folder], and store
    * dependency information in [info]. Return `null` if no package map can
    * be computed.
    */
   UriResolver _computePackageUriResolver(Folder folder, _ContextInfo info) {
     if (info.packageRoot != null) {
-      info.packageMapDependencies = new Set<String>();
+      info.packageMapInfo = null;
       return new PackageUriResolver([new JavaFile(info.packageRoot)]);
     } else {
       beginComputePackageMap();
-      PackageMapInfo packageMapInfo;
+      OptimizingPubPackageMapInfo packageMapInfo;
       ServerPerformanceStatistics.pub.makeCurrentWhile(() {
-        packageMapInfo = _packageMapProvider.computePackageMap(folder);
+        packageMapInfo =
+            _packageMapProvider.computePackageMap(folder, info.packageMapInfo);
       });
       endComputePackageMap();
-      info.packageMapDependencies = packageMapInfo.dependencies;
+      info.packageMapInfo = packageMapInfo;
       if (packageMapInfo.packageMap == null) {
         return null;
       }
       return new PackageMapUriResolver(
           resourceProvider, packageMapInfo.packageMap);
       // TODO(paulberry): if any of the dependencies is outside of [folder],
       // we'll need to watch their parent folders as well.
     }
   }
 
@@ skipping 176 matching lines @@
         if (!sources.isEmpty) {
           ChangeSet changeSet = new ChangeSet();
           sources.forEach((Source source) {
             changeSet.changedSource(source);
           });
           applyChangesToContext(folder, changeSet);
         }
         break;
     }
 
-    if (info.packageMapDependencies.contains(path)) {
+    if (info.packageMapInfo != null &&
+        info.packageMapInfo.isChangedDependency(path, resourceProvider)) {
       _recomputePackageUriResolver(info);
     }
   }
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
   bool _isExcluded(String path) {
     return _isExcludedBy(excludedPaths, path);
   }
@@ skipping 129 matching lines @@
    */
   AnalysisContext context;
 
   /**
    * Map from full path to the [Source] object, for each source that has been
    * added to the context.
    */
   Map<String, Source> sources = new HashMap<String, Source>();
 
   /**
-   * Dependencies of the context's package map.
-   * If any of these files changes, the package map needs to be recomputed.
+   * Info returned by the last call to
+   * [OptimizingPubPackageMapProvider.computePackageMap], or `null` if the
+   * package map hasn't been computed for this context yet.
    */
-  Set<String> packageMapDependencies;
+  OptimizingPubPackageMapInfo packageMapInfo;
 
   _ContextInfo(this.folder, File pubspecFile, this.children, this.packageRoot) {
     pubspecPath = pubspecFile.path;
     for (_ContextInfo child in children) {
       child.parent = this;
     }
   }
 
   /**
    * Returns `true` if this context is root folder based.
@@ skipping 16 matching lines @@
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }