Generalize the dependency tracking mechanism used by ContextManager.

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 'dart:convert';
 import 'dart:core' hide Resource;
@@ skipping 16 matching lines @@
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 import 'package:yaml/yaml.dart';
 
 /**
  * Information tracked by the [ContextManager] for each context.
  */
 class ContextInfo {
   /**
+   * The [ContextManager] which is tracking this information.
+   */
+  final ContextManagerImpl contextManager;
+
+  /**
    * The [Folder] for which this information object is created.
    */
   final Folder folder;
 
   /// The [PathFilter] used to filter sources from being analyzed.
   final PathFilter pathFilter;
 
   /**
    * The enclosed pubspec-based contexts.
    */
@@ skipping 17 matching lines @@
   String packageDescriptionPath;
 
   /**
    * Stream subscription we are using to watch the context's directory for
    * changes.
    */
   StreamSubscription<WatchEvent> changeSubscription;
 
   /**
    * Stream subscriptions we are using to watch the files
-   * used to determine the package map.
+   * used to determine the package map.  Organized as a map from path to
+   * subscription.
+   *
+   * For paths that are inside [folder], the subscription is null, since the
+   * entire contents of the folder are automatically being watched.
    */
-  final List<StreamSubscription<WatchEvent>> dependencySubscriptions =
-      <StreamSubscription<WatchEvent>>[];
+  final Map<String, StreamSubscription<WatchEvent>> _dependencySubscriptions =
+      <String, StreamSubscription<WatchEvent>>{};
 
   /**
    * The analysis context that was created for the [folder].
    */
   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>();
 
-  /**
-   * Info returned by the last call to
-   * [OptimizingPubPackageMapProvider.computePackageMap], or `null` if the
-   * package map hasn't been computed for this context yet.
-   */
-  PackageMapInfo packageMapInfo;
-
-  ContextInfo(
-      this.parent, Folder folder, File packagespecFile, this.packageRoot)
+  ContextInfo(this.contextManager, this.parent, Folder folder,
+      File packagespecFile, this.packageRoot)
       : folder = folder,
         pathFilter = new PathFilter(folder.path, null) {
     packageDescriptionPath = packagespecFile.path;
     parent.children.add(this);
   }
 
   /**
    * Create the virtual [ContextInfo] which acts as an ancestor to all other
    * [ContextInfo]s.
    */
   ContextInfo._root()
-      : folder = null,
+      : contextManager = null,
+        folder = null,
         pathFilter = null;
 
   /**
    * Iterate through all [children] and their children, recursively.
    */
   Iterable<ContextInfo> get descendants sync* {
     for (ContextInfo child in children) {
       yield child;
       yield* child.descendants;
     }
@@ skipping 26 matching lines @@
    */
   ContextInfo findChildInfoFor(String path) {
     for (ContextInfo info in children) {
       if (info.folder.isOrContains(path)) {
         return info;
       }
     }
     return null;
   }
 
+  /**
+   * Determine if the given [path] is one of the dependencies most recently
+   * passed to [setDependencies].
+   */
+  bool hasDependency(String path) => _dependencySubscriptions.containsKey(path);
+
   /// Returns `true` if  [path] should be ignored.
   bool ignored(String path) => pathFilter.ignored(path);
 
   /**
    * Returns `true` if [path] is the package description file for this context
    * (pubspec.yaml or .packages).
    */
   bool isPathToPackageDescription(String path) =>
       path == packageDescriptionPath;
+
+  /**
+   * Update the set of dependencies for this context.  Watchers are
+   * automatically set up for the dependencies (if necessary) to ensure that
+   * [ContextManagerImpl._handleWatchEvent] is called when they are modified.
+   */
+  void setDependencies(Iterable<String> newDependencies) {
+    for (String oldDependency in _dependencySubscriptions.keys.toList()) {
+      if (!newDependencies.contains(oldDependency)) {
+        StreamSubscription<WatchEvent> subscription =
+            _dependencySubscriptions[oldDependency];
+        if (subscription != null) {
+          subscription.cancel();
+        }
+        _dependencySubscriptions.remove(oldDependency);
+      }
+    }
+    for (String newDependency in newDependencies) {
+      if (!_dependencySubscriptions.containsKey(newDependency)) {
+        StreamSubscription<WatchEvent> subscription;
+        if (!folder.contains(newDependency)) {
+          Resource resource =
+              contextManager.resourceProvider.getResource(newDependency);
+          if (resource is File) {
+            subscription = resource.changes.listen((WatchEvent event) {
+              contextManager._handleWatchEvent(folder, this, event);
+            }, onError: (error, StackTrace stackTrace) {
+              // Gracefully degrade if file is or becomes unwatchable
+              contextManager._instrumentationService.logException(
+                  error, stackTrace);
+              subscription.cancel();
+              _dependencySubscriptions[newDependency] = null;
+            });
+          }
+        }
+        _dependencySubscriptions[newDependency] = subscription;
+      }
+    }
+  }
 }
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 abstract class ContextManager {
   // TODO(brianwilkerson) Support:
   //   setting the default analysis options
   //   setting the default content cache
@@ skipping 479 matching lines @@
         }
         _addSourceFiles(changeSet, child, info);
       }
     }
   }
 
   /**
    * Cancel all dependency subscriptions for the given context.
    */
   void _cancelDependencySubscriptions(ContextInfo info) {
-    for (StreamSubscription<WatchEvent> s in info.dependencySubscriptions) {
-      s.cancel();
-    }
-    info.dependencySubscriptions.clear();
+    info.setDependencies(const <String>[]);
   }
 
   void _checkForPackagespecUpdate(
       String path, ContextInfo info, Folder folder) {
     // Check to see if this is the .packages file for this context and if so,
     // update the context's source factory.
     if (pathContext.basename(path) == PACKAGE_SPEC_NAME &&
         info.isPathToPackageDescription(path)) {
       File packagespec = resourceProvider.getFile(path);
       if (packagespec.exists) {
@@ skipping 23 matching lines @@
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
   /**
-   * Compute the appropriate [FolderDisposition] for [folder], and store
-   * dependency information in [info].
+   * Compute the appropriate [FolderDisposition] for [info].  Use
+   * [addDependency] to indicate which files needed to be consulted in order to
+   * figure out the [FolderDisposition]; these dependencies will be watched in
+   * order to determine when it is necessary to call this function again.
+   *
+   * TODO(paulberry): use [addDependency] for tracking all folder disposition
+   * dependencies (currently we only use it to track "pub list" dependencies).
    */
-  FolderDisposition _computeFolderDisposition(Folder folder, ContextInfo info) {
-    _cancelDependencySubscriptions(info);
+  FolderDisposition _computeFolderDisposition(
+      Folder folder, ContextInfo info, void addDependency(String path)) {
     if (info.packageRoot != null) {
-      info.packageMapInfo = null;
       // TODO(paulberry): We shouldn't be using JavaFile here because it
       // makes the code untestable (see dartbug.com/23909).
       JavaFile packagesDir = new JavaFile(info.packageRoot);
       Map<String, List<Folder>> packageMap = new Map<String, List<Folder>>();
       if (packagesDir.isDirectory()) {
         for (JavaFile file in packagesDir.listFiles()) {
           // Ensure symlinks in packages directory are canonicalized
           // to prevent 'type X cannot be assigned to type X' warnings
           String path;
           try {
@@ skipping 23 matching lines @@
         if (resolver != null) {
           return new CustomPackageResolverDisposition(resolver);
         }
       }
       PackageMapInfo packageMapInfo;
       ServerPerformanceStatistics.pub.makeCurrentWhile(() {
         packageMapInfo = _packageMapProvider.computePackageMap(folder);
       });
       callbacks.endComputePackageMap();
       for (String dependencyPath in packageMapInfo.dependencies) {
-        Resource resource = resourceProvider.getResource(dependencyPath);
-        if (resource is File) {
-          StreamSubscription<WatchEvent> subscription;
-          subscription = resource.changes.listen((WatchEvent event) {
-            if (info.packageMapInfo != null &&
-                info.packageMapInfo.dependencies.contains(dependencyPath)) {
-              _recomputeFolderDisposition(info);
-            }
-          }, onError: (error, StackTrace stackTrace) {
-            // Gracefully degrade if file is or becomes unwatchable
-            _instrumentationService.logException(error, stackTrace);
-            subscription.cancel();
-            info.dependencySubscriptions.remove(subscription);
-          });
-          info.dependencySubscriptions.add(subscription);
-        }
+        addDependency(dependencyPath);
       }
-      info.packageMapInfo = packageMapInfo;
       if (packageMapInfo.packageMap == null) {
         return new NoPackageFolderDisposition();
       }
       return new PackageMapDisposition(packageMapInfo.packageMap);
     }
   }
 
   /**
    * Create a new empty context associated with [folder], having parent
    * [parent] and using [packagespecFile] to resolve package URI's.
    */
   ContextInfo _createContext(
       ContextInfo parent, Folder folder, File packagespecFile) {
-    ContextInfo info = new ContextInfo(
-        parent, folder, packagespecFile, normalizedPackageRoots[folder.path]);
+    ContextInfo info = new ContextInfo(this, parent, folder, packagespecFile,
+        normalizedPackageRoots[folder.path]);
     Map<String, YamlNode> options = analysisOptionsProvider.getOptions(folder);
     processOptionsForContext(info, options);
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     try {
       FolderDisposition disposition;
+      List<String> dependencies = <String>[];
 
       if (ENABLE_PACKAGESPEC_SUPPORT) {
         // Try .packages first.
         if (pathos.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
           Packages packages = _readPackagespec(packagespecFile);
           disposition = new PackagesFileDisposition(packages);
         }
       }
 
       // Next resort to a package uri resolver.
       if (disposition == null) {
-        disposition = _computeFolderDisposition(folder, info);
+        disposition = _computeFolderDisposition(folder, info, dependencies.add);
       }
 
+      info.setDependencies(dependencies);
       info.context = callbacks.addContext(folder, disposition);
       info.context.name = folder.path;
     } catch (_) {
       info.changeSubscription.cancel();
       rethrow;
     }
     return info;
   }
 
   /**
@@ skipping 122 matching lines @@
   }
 
   void _handleWatchEvent(Folder folder, ContextInfo info, WatchEvent event) {
     // TODO(brianwilkerson) If a file is explicitly included in one context
     // but implicitly referenced in another context, we will only send a
     // changeSet to the context that explicitly includes the file (because
     // that's the only context that's watching the file).
     _instrumentationService.logWatchEvent(
         folder.path, event.path, event.type.toString());
     String path = event.path;
+    // First handle changes that affect folderDisposition (since these need to
+    // be processed regardless of whether they are part of an excluded/ignored
+    // path).
+    if (info.hasDependency(path)) {
+      _recomputeFolderDisposition(info);
+    }
     // maybe excluded globally
     if (_isExcluded(path)) {
       return;
     }
     // maybe excluded from the context, so other context will handle it
     if (info.excludes(path)) {
       return;
     }
     if (info.ignored(path)) {
       return;
@@ skipping 111 matching lines @@
           sources.forEach((Source source) {
             changeSet.changedSource(source);
           });
           callbacks.applyChangesToContext(folder, changeSet);
         }
         break;
     }
 
     //TODO(pquitslund): find the right place for this
     _checkForPackagespecUpdate(path, info, folder);
-
-    if (info.packageMapInfo != null &&
-        info.packageMapInfo.dependencies.contains(path)) {
-      _recomputeFolderDisposition(info);
-    }
   }
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
   bool _isExcluded(String path) => _isExcludedBy(excludedPaths, path);
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
@@ skipping 54 matching lines @@
 
   /**
    * Recompute the [FolderDisposition] for the context described by [info],
    * and update the client appropriately.
    */
   void _recomputeFolderDisposition(ContextInfo info) {
     // TODO(paulberry): when computePackageMap is changed into an
     // asynchronous API call, we'll want to suspend analysis for this context
     // while we're rerunning "pub list", since any analysis we complete while
     // "pub list" is in progress is just going to get thrown away anyhow.
+    List<String> dependencies = <String>[];
     FolderDisposition disposition =
-        _computeFolderDisposition(info.folder, info);
+        _computeFolderDisposition(info.folder, info, dependencies.add);
+    info.setDependencies(dependencies);
     callbacks.updateContextPackageUriResolver(info.folder, disposition);
   }
 
   /**
    * Create and return a source representing the given [file] within the given
    * [context].
    */
   static Source createSourceInContext(AnalysisContext context, File file) {
     // TODO(brianwilkerson) Optimize this, by allowing support for source
     // factories to restore URI's from a file path rather than a source.
@@ skipping 133 matching lines @@
 class PackagesFileDisposition extends FolderDisposition {
   @override
   final Packages packages;
 
   PackagesFileDisposition(this.packages) {}
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider) => const <UriResolver>[];
 }