Watch analysis roots separately.

pkg/analysis_server/lib/src/single_context_manager.dart

 // Copyright (c) 2016, 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 analysis_server.src.single_context_manager;
 
 import 'dart:async';
 import 'dart:core' hide Resource;
 import 'dart:math' as math;
 
@@ skipping 77 matching lines @@
    * The context in which everything is being analyzed.
    */
   AnalysisContext context;
 
   /**
    * The folder associated with the context.
    */
   Folder contextFolder;
 
   /**
-   * The current [contextFolder] watch subscription.
+   * The current watch subscriptions.
    */
-  StreamSubscription<WatchEvent> watchSubscription;
+  Map<String, StreamSubscription<WatchEvent>> watchSubscriptions =
+      new Map<String, StreamSubscription<WatchEvent>>();
 
   /**
    * The [packageResolverProvider] must not be `null`.
    */
   SingleContextManager(this.resourceProvider, this.sdkManager,
       this.packageResolverProvider, this.analyzedFilesGlobs) {
     pathContext = resourceProvider.pathContext;
   }
 
   @override
@@ skipping 32 matching lines @@
         !_isContainedIn(excludedPaths, path);
   }
 
   @override
   void refresh(List<Resource> roots) {
     if (context != null) {
       callbacks.removeContext(contextFolder, null);
       context.dispose();
       context = null;
       contextFolder = null;
-      if (watchSubscription != null) {
-        watchSubscription.cancel();
-        watchSubscription = null;
-      }
+      _cancelCurrentWatchSubscriptions();
       setRoots(includedPaths, excludedPaths, packageRoots);
     }
   }
 
   @override
   void setRoots(List<String> includedPaths, List<String> excludedPaths,
       Map<String, String> packageRoots) {
     includedPaths = _nonOverlappingPaths(includedPaths);
     excludedPaths = _nonOverlappingPaths(excludedPaths);
     this.packageRoots = packageRoots;
     _updateNormalizedPackageRoots();
     // Update context path.
     {
       String contextPath = _commonPrefix(includedPaths);
       Folder contextFolder = resourceProvider.getFolder(contextPath);
       if (contextFolder != this.contextFolder) {
         if (context != null) {
           callbacks.moveContext(this.contextFolder, contextFolder);
         }
         this.contextFolder = contextFolder;
-        // Start new watcher and cancel the old one.
-        StreamSubscription<WatchEvent> watchSubscription =
-            this.contextFolder.changes.listen(_handleWatchEvent);
-        this.watchSubscription?.cancel();
-        this.watchSubscription = watchSubscription;
       }
     }
+    // Start new watchers and cancel old ones.
+    {
+      Map<String, StreamSubscription<WatchEvent>> newSubscriptions =
+          new Map<String, StreamSubscription<WatchEvent>>();
+      for (String includedPath in includedPaths) {
+        Resource resource = resourceProvider.getResource(includedPath);
+        if (resource is Folder) {
+          // Extract the existing subscription or create a new one.
+          StreamSubscription<WatchEvent> subscription =
+              watchSubscriptions.remove(includedPath);
+          if (subscription == null) {
+            subscription = resource.changes.listen(_handleWatchEvent);
+          }
+          // Remember the subscription.
+          newSubscriptions[includedPath] = subscription;
+        }
+        _cancelCurrentWatchSubscriptions();
+        this.watchSubscriptions = newSubscriptions;
+      }
+    }
+    // Create or update the analysis context.
     if (context == null) {
       UriResolver packageResolver = packageResolverProvider();
       context = callbacks.addContext(contextFolder, new AnalysisOptionsImpl(),
           new CustomPackageResolverDisposition(packageResolver));
       ChangeSet changeSet =
           _buildChangeSet(added: _includedFiles(includedPaths, excludedPaths));
       callbacks.applyChangesToContext(contextFolder, changeSet);
     } else {
       // TODO(brianwilkerson) Optimize this.
       List<File> oldFiles =
@@ skipping 41 matching lines @@
     }
     if (removed != null) {
       for (File file in removed) {
         Source source = createSourceInContext(context, file);
         changeSet.removedSource(source);
       }
     }
     return changeSet;
   }
 
+  void _cancelCurrentWatchSubscriptions() {
+    for (StreamSubscription<WatchEvent> subscription
+        in watchSubscriptions.values) {
+      subscription.cancel();
+    }
+    watchSubscriptions.clear();
+  }
+
   String _commonPrefix(List<String> paths) {
     if (paths.isEmpty) {
       return '';
     }
     List<String> left = pathContext.split(paths[0]);
     int count = left.length;
     for (int i = 1; i < paths.length; i++) {
       List<String> right = pathContext.split(paths[i]);
       count = _commonComponents(left, count, right);
     }
@@ skipping 218 matching lines @@
   static List<Resource> _getChildrenSafe(Folder folder) {
     try {
       return folder.getChildren();
     } on FileSystemException {
       // The folder either doesn't exist or cannot be read.
       // Either way, there are no children.
       return const <Resource>[];
     }
   }
 }