Convert ContextManager to recursively watch analysis roots.

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 51 matching lines @@
    * objects.
    */
   ContextInfo parent;
 
   /**
    * The package description file path for this context.
    */
   String packageDescriptionPath;
 
   /**
-   * Stream subscription we are using to watch the context's directory for
-   * changes.
+   * Paths to files which determine the folder disposition and package map.
+   *
+   * TODO(paulberry): if any of these files are outside of [folder], they won't
+   * be watched for changes.  I believe the use case for watching these files
+   * is no longer relevant.
    */
-  StreamSubscription<WatchEvent> changeSubscription;
-
-  /**
-   * Stream subscriptions we are using to watch the files
-   * 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 Map<String, StreamSubscription<WatchEvent>> _dependencySubscriptions =
-      <String, StreamSubscription<WatchEvent>>{};
+  Set<String> _dependencies = new Set<String>();
 
   /**
    * 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.
    */
@@ skipping 57 matching lines @@
         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);
+  bool hasDependency(String path) => _dependencies.contains(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.
+   * Update the set of dependencies for this context.
    */
   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;
-      }
-    }
+    _dependencies = newDependencies.toSet();
   }
 }
 
 /**
  * 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
@@ skipping 203 matching lines @@
 
   @override
   ContextManagerCallbacks callbacks;
 
   /**
    * Virtual [ContextInfo] which acts as the ancestor of all other
    * [ContextInfo]s.
    */
   final ContextInfo _rootInfo = new ContextInfo._root();
 
+  /**
+   * Stream subscription we are using to watch each analysis root directory for
+   * changes.
+   */
+  final Map<Folder, StreamSubscription<WatchEvent>> _changeSubscriptions =
+      <Folder, StreamSubscription<WatchEvent>>{};
+
   ContextManagerImpl(this.resourceProvider, this.packageResolverProvider,
       this._packageMapProvider, this._instrumentationService) {
     pathContext = resourceProvider.pathContext;
   }
 
   @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     ContextInfo innermostContainingInfo =
         _getInnermostContextInfoFor(analysisRoot.path);
@@ skipping 138 matching lines @@
         info.packageRoot = newPackageRoot;
         _recomputeFolderDisposition(info);
       }
     }
     // create new contexts
     for (Folder includedFolder in includedFolders) {
       bool wasIncluded = contextInfos.any((info) {
         return info.folder.isOrContains(includedFolder.path);
       });
       if (!wasIncluded) {
+        _changeSubscriptions[includedFolder] =
+            includedFolder.changes.listen(_handleWatchEvent);
         _createContexts(_rootInfo, includedFolder, false);
       }
     }
     // remove newly excluded sources
     for (ContextInfo info in _rootInfo.descendants) {
       // prepare excluded sources
       Map<String, Source> excludedSources = new HashMap<String, Source>();
       info.sources.forEach((String path, Source source) {
         if (_isExcludedBy(excludedPaths, path) &&
             !_isExcludedBy(oldExcludedPaths, path)) {
@@ skipping 95 matching lines @@
       } else if (child is Folder) {
         String shortName = child.shortName;
         if (shortName == PACKAGES_NAME) {
           continue;
         }
         _addSourceFiles(changeSet, child, info);
       }
     }
   }
 
-  /**
-   * Cancel all dependency subscriptions for the given context.
-   */
-  void _cancelDependencySubscriptions(ContextInfo info) {
-    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) {
         Packages packages = _readPackagespec(packagespec);
         if (packages != null) {
@@ skipping 21 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 [info].  Use
+   * Compute the appropriate [FolderDisposition] for [folder].  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, void addDependency(String path)) {
-    if (info.packageRoot != null) {
+      Folder folder, void addDependency(String path)) {
+    String packageRoot = normalizedPackageRoots[folder.path];
+    if (packageRoot != 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);
+      JavaFile packagesDir = new JavaFile(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 {
             path = file.getCanonicalPath();
           } catch (e, s) {
             // Ignore packages that do not exist
             _instrumentationService.logException(e, s);
             continue;
           }
           Resource res = resourceProvider.getResource(path);
           if (res is Folder) {
             packageMap[file.getName()] = <Folder>[res];
           }
         }
-        return new PackageMapDisposition(packageMap,
-            packageRoot: info.packageRoot);
+        return new PackageMapDisposition(packageMap, packageRoot: packageRoot);
       }
       // The package root does not exist (or is not a folder).  Since
       // [setRoots] ignores any package roots that don't exist (or aren't
       // folders), the only way we should be able to get here is due to a race
       // condition.  In any case, the package root folder is gone, so we can't
       // resolve packages.
-      return new NoPackageFolderDisposition(packageRoot: info.packageRoot);
+      return new NoPackageFolderDisposition(packageRoot: packageRoot);
     } else {
       callbacks.beginComputePackageMap();
       if (packageResolverProvider != null) {
         UriResolver resolver = packageResolverProvider(folder);
         if (resolver != null) {
           return new CustomPackageResolverDisposition(resolver);
         }
       }
       PackageMapInfo packageMapInfo;
       ServerPerformanceStatistics.pub.makeCurrentWhile(() {
@@ skipping 13 matching lines @@
   /**
    * 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(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>[];
+    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);
-        }
+    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, dependencies.add);
-      }
+    // Next resort to a package uri resolver.
+    if (disposition == null) {
+      disposition = _computeFolderDisposition(folder, dependencies.add);
+    }
 
-      info.setDependencies(dependencies);
-      info.context = callbacks.addContext(folder, disposition);
-      info.context.name = folder.path;
-    } catch (_) {
-      info.changeSubscription.cancel();
-      rethrow;
-    }
+    info.setDependencies(dependencies);
+    info.context = callbacks.addContext(folder, disposition);
+    info.context.name = folder.path;
     return info;
   }
 
   /**
    * Potentially create a new context associated with the given [folder].
    *
    * If there are subfolders with 'pubspec.yaml' files, separate contexts are
    * created for them and excluded from the context associated with the
    * [folder].
    *
@@ skipping 42 matching lines @@
       ChangeSet changeSet = new ChangeSet();
       _addSourceFiles(changeSet, folder, parent);
       callbacks.applyChangesToContext(folder, changeSet);
     }
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(ContextInfo info) {
-    info.changeSubscription.cancel();
-    _cancelDependencySubscriptions(info);
+    if (_changeSubscriptions.containsKey(info.folder)) {
+      _changeSubscriptions[info.folder].cancel();
+    }
     callbacks.removeContext(info.folder, _computeFlushedFiles(info));
     bool wasRemoved = info.parent.children.remove(info);
     assert(wasRemoved);
   }
 
   /**
    * Extract a new [packagespecFile]-based context from [oldInfo].
    */
   void _extractContext(ContextInfo oldInfo, File packagespecFile) {
     Folder newFolder = packagespecFile.parent;
@@ skipping 44 matching lines @@
     }
     while (true) {
       ContextInfo childInfo = info.findChildInfoFor(path);
       if (childInfo == null) {
         return info;
       }
       info = childInfo;
     }
   }
 
-  void _handleWatchEvent(Folder folder, ContextInfo info, WatchEvent event) {
+  void _handleWatchEvent(WatchEvent event) {
+    // Figure out which context this event applies to.
     // 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).
+    ContextInfo info = _getInnermostContextInfoFor(event.path);
+    if (info == null) {
+      // This event doesn't apply to any context.  This could happen due to a
+      // race condition (e.g. a context was removed while one of its events was
+      // in the event loop).  The event is inapplicable now, so just ignore it.
+      return;
+    }
     _instrumentationService.logWatchEvent(
-        folder.path, event.path, event.type.toString());
+        info.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;
     }
     // handle the change
     switch (event.type) {
       case ChangeType.ADD:
-        if (_isInPackagesDir(path, folder)) {
+        if (_isInPackagesDir(path, info.folder)) {
           return;
         }
 
         Resource resource = resourceProvider.getResource(path);
 
         if (ENABLE_PACKAGESPEC_SUPPORT) {
           String directoryPath = pathContext.dirname(path);
 
           // Check to see if we need to create a new context.
           if (info.isTopLevel) {
@@ skipping 31 matching lines @@
 
         // If the file went away and was replaced by a folder before we
         // had a chance to process the event, resource might be a Folder.  In
         // that case don't add it.
         if (resource is File) {
           File file = resource;
           if (callbacks.shouldFileBeAnalyzed(file)) {
             ChangeSet changeSet = new ChangeSet();
             Source source = createSourceInContext(info.context, file);
             changeSet.addedSource(source);
-            callbacks.applyChangesToContext(folder, changeSet);
+            callbacks.applyChangesToContext(info.folder, changeSet);
             info.sources[path] = source;
           }
         }
         break;
       case ChangeType.REMOVE:
 
         // If package spec info is removed, check to see if we can merge contexts.
         // Note that it's important to verify that there is NEITHER a .packages nor a
         // lingering pubspec.yaml before merging.
         if (!info.isTopLevel) {
@@ skipping 26 matching lines @@
             }
           }
         }
 
         List<Source> sources = info.context.getSourcesWithFullName(path);
         if (!sources.isEmpty) {
           ChangeSet changeSet = new ChangeSet();
           sources.forEach((Source source) {
             changeSet.removedSource(source);
           });
-          callbacks.applyChangesToContext(folder, changeSet);
+          callbacks.applyChangesToContext(info.folder, changeSet);
           info.sources.remove(path);
         }
         break;
       case ChangeType.MODIFY:
         List<Source> sources = info.context.getSourcesWithFullName(path);
         if (!sources.isEmpty) {
           ChangeSet changeSet = new ChangeSet();
           sources.forEach((Source source) {
             changeSet.changedSource(source);
           });
-          callbacks.applyChangesToContext(folder, changeSet);
+          callbacks.applyChangesToContext(info.folder, changeSet);
         }
         break;
     }
 
     //TODO(pquitslund): find the right place for this
-    _checkForPackagespecUpdate(path, info, folder);
+    _checkForPackagespecUpdate(path, info, info.folder);
   }
 
   /**
    * 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 56 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, dependencies.add);
+        _computeFolderDisposition(info.folder, 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
@@ skipping 151 matching lines @@
 
   PackagesFileDisposition(this.packages) {}
 
   @override
   String get packageRoot => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider) => const <UriResolver>[];
 }