recompute package map when input file changes

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';
@@ skipping 369 matching lines @@
         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) {
+    for (StreamSubscription<WatchEvent> s in info.dependencySubscriptions) {
+      s.cancel();
+    }
+    info.dependencySubscriptions.clear();
+  }
+
+  /**
    * 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) {
+    _cancelDependencySubscriptions(info);
     if (info.packageRoot != null) {
       info.packageMapInfo = null;
       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 13 matching lines @@
       //TODO(danrubel) remove this if it will never be called
       return new PackageUriResolver([packagesDir]);
     } else {
       beginComputePackageMap();
       OptimizingPubPackageMapInfo packageMapInfo;
       ServerPerformanceStatistics.pub.makeCurrentWhile(() {
         packageMapInfo =
             _packageMapProvider.computePackageMap(folder, info.packageMapInfo);
       });
       endComputePackageMap();
+      for (String dependencyPath in packageMapInfo.dependencies) {
+        Resource resource = resourceProvider.getResource(dependencyPath);
+        if (resource is File) {
+          info.dependencySubscriptions.add(resource.changes
+              .listen((WatchEvent event) {
+            if (info.packageMapInfo != null &&
+                info.packageMapInfo.isChangedDependency(
+                    dependencyPath, resourceProvider)) {
+              _recomputePackageUriResolver(info);
+            }
+          }));
+        }
+      }
       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 68 matching lines @@
     ChangeSet changeSet = new ChangeSet();
     _addSourceFiles(changeSet, folder, info);
     applyChangesToContext(folder, changeSet);
     return info;
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(Folder folder) {
-    _contexts[folder].changeSubscription.cancel();
+    _ContextInfo info = _contexts[folder];
+    info.changeSubscription.cancel();
+    _cancelDependencySubscriptions(info);
     removeContext(folder);
     _contexts.remove(folder);
   }
 
   /**
    * Extract a new [pubspecFile]-based context from [oldInfo].
    */
   void _extractContext(_ContextInfo oldInfo, File pubspecFile) {
     Folder newFolder = pubspecFile.parent;
     _ContextInfo newInfo = _createContext(newFolder, pubspecFile, []);
@@ skipping 215 matching lines @@
    */
   String pubspecPath;
 
   /**
    * 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.
+   */
+  final List<StreamSubscription<WatchEvent>> dependencySubscriptions =
+      <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>();
 
@@ skipping 32 matching lines @@
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }