Add support for watch events and error notifications

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';
@@ skipping 368 matching lines @@
    * changes that need to be applied to the context.
    */
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
    * The given [file] was removed from the folder analyzed in the [driver].
    */
   void applyFileRemoved(AnalysisDriver driver, String file);
 
   /**
+   * Sent the given watch [event] to any interested plugins.
+   */
+  void broadcastWatchEvent(WatchEvent event);
+
+  /**
    * Signals that the context manager has started to compute a package map (if
    * [computing] is `true`) or has finished (if [computing] is `false`).
    */
   void computingPackageMap(bool computing);
 
   /**
    * Create and return a context builder that can be used to create a context
    * for the files in the given [folder] when analyzed using the given [options].
    */
   ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options);
@@ skipping 989 matching lines @@
     }
     return rootInfo;
   }
 
   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);
+    callbacks.broadcastWatchEvent(event);
+    String path = event.path;
+    ChangeType type = event.type;
+    ContextInfo info = _getInnermostContextInfoFor(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(
-        info.folder.path, event.path, event.type.toString());
-    String path = event.path;
+        info.folder.path, path, type.toString());
     // 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) ||
         _isContainedInDotFolder(info.folder.path, path) ||
         _isInPackagesDir(info.folder.path, path) ||
         _isInTopLevelDocDir(info.folder.path, 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) {
+    switch (type) {
       case ChangeType.ADD:
         Resource resource = resourceProvider.getResource(path);
 
         String directoryPath = absolutePathContext.dirname(path);
 
         // Check to see if we need to create a new context.
         if (info.isTopLevel) {
           // Only create a new context if this is not the same directory
           // described by our info object.
           if (info.folder.path != directoryPath) {
@@ skipping 96 matching lines @@
             ChangeSet changeSet = new ChangeSet();
             sources.forEach((Source source) {
               changeSet.changedSource(source);
             });
             callbacks.applyChangesToContext(info.folder, changeSet);
           }
         }
         break;
     }
     _checkForPackagespecUpdate(path, info, info.folder);
-    _checkForAnalysisOptionsUpdate(path, info, event.type);
+    _checkForAnalysisOptionsUpdate(path, info, type);
   }
 
   /**
    * Determine whether the given [path], when interpreted relative to the
    * context root [root], contains a folder whose name starts with '.'.
    */
   bool _isContainedInDotFolder(String root, String path) {
     String pathDir = absolutePathContext.dirname(path);
     String suffixPath = absolutePathContext.suffix(root, pathDir);
     if (suffixPath == null) {
@@ skipping 410 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }