Improve default support provided for plugins

pkg/analyzer_plugin/lib/plugin/plugin.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart'
     show AnalysisDriverGeneric, AnalysisDriverScheduler, PerformanceLog;
 import 'package:analyzer/src/dart/analysis/file_byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
@@ skipping 160 matching lines @@
   /**
    * Create an analysis driver that can analyze the files within the given
    * [contextRoot].
    */
   AnalysisDriverGeneric createAnalysisDriver(ContextRoot contextRoot);
 
   /**
    * Handle an 'analysis.handleWatchEvents' request.
    */
   AnalysisHandleWatchEventsResult handleAnalysisHandleWatchEvents(
-          AnalysisHandleWatchEventsParams parameters) =>
-      null;
+      AnalysisHandleWatchEventsParams parameters) {
+    for (WatchEvent event in parameters.events) {
+      switch (event.type) {
+        case WatchEventType.ADD:
+          // TODO(brianwilkerson) Handle the event.
+          break;
+        case WatchEventType.MODIFY:
+          contentChanged(event.path);
+          break;
+        case WatchEventType.REMOVE:
+          // TODO(brianwilkerson) Handle the event.
+          break;
+        default:
+          // Ignore unhandled watch event types.
+          break;
+      }
+    }
+    return new AnalysisHandleWatchEventsResult();
+  }
 
   /**
    * Handle an 'analysis.reanalyze' request.
    */
   AnalysisReanalyzeResult handleAnalysisReanalyze(
-          AnalysisReanalyzeParams parameters) =>
-      null;
+      AnalysisReanalyzeParams parameters) {
+    var rootPaths = parameters.roots;
+    if (rootPaths == null) {
+      //
+      // Reanalyze everything.
+      //
+      List<ContextRoot> roots = driverMap.keys.toList();
+      for (ContextRoot contextRoot in roots) {

[scheglov, 2017/05/08 16:45:43]

Do we want to handle this as "reanalyze contexts" or "recreate contexts for
previously set analysis roots"? Because in general the might be different number
of contexts now, e.g. the user added some pubspec.yaml files.

[Brian Wilkerson, 2017/05/08 17:01:10]

Interesting question. My intuition is that (a) changes that alter the context
structure are fairly rare and (b) we'll get watch events for those changes. That
implies to me that it will generally be faster to not re-do the work of finding
context roots most of the time. WDYT?

+        AnalysisDriverGeneric driver = driverMap[contextRoot];
+        driver.dispose();
+        driver = createAnalysisDriver(contextRoot);
+        driverMap[contextRoot] = driver;
+      }
+      return new AnalysisReanalyzeResult();
+    } else {
+      //
+      // Reanalyze a specific set of files.
+      //
+      // TODO(brianwilkerson) There is no API for telling a driver that we need
+      // to have some files reanalyzed.
+//      for (String rootPath in rootPaths) {
+//        ContextRoot contextRoot = contextRootContaining(rootPath);
+//        AnalysisDriverGeneric driver = driverMap[contextRoot];
+//        driver.reanalyze(rootPath);
+//      }
+      return null;
+    }
+  }
 
   /**
    * Handle an 'analysis.setContextBuilderOptions' request.
    */
   AnalysisSetContextBuilderOptionsResult handleAnalysisSetContextBuilderOptions(
           AnalysisSetContextBuilderOptionsParams parameters) =>
       null;
 
   /**
    * Handle an 'analysis.setContextRoots' request.
@@ skipping 43 matching lines @@
   }
 
   /**
    * Handle an 'analysis.setSubscriptions' request. Most subclasses should not
    * override this method, but should instead use the [subscriptionManager] to
    * access the list of subscriptions for any given file.
    */
   AnalysisSetSubscriptionsResult handleAnalysisSetSubscriptions(
       AnalysisSetSubscriptionsParams parameters) {
     Map<AnalysisService, List<String>> subscriptions = parameters.subscriptions;
-    subscriptionManager.setSubscriptions(subscriptions);
-    // TODO(brianwilkerson) Cause any newly subscribed for notifications to be sent.
+    Map<String, List<AnalysisService>> newSubscriptions =
+        subscriptionManager.setSubscriptions(subscriptions);
+    sendNotificationsForSubscriptions(newSubscriptions);
     return new AnalysisSetSubscriptionsResult();
   }
 
   /**
    * Handle an 'analysis.updateContent' request. Most subclasses should not
    * override this method, but should instead use the [contentCache] to access
    * the current content of overlaid files.
    */
   AnalysisUpdateContentResult handleAnalysisUpdateContent(
       AnalysisUpdateContentParams parameters) {
     Map<String, Object> files = parameters.files;
     files.forEach((String filePath, Object overlay) {
       // We don't need to get the correct URI because only the full path is
       // used by the contentCache.
       Source source = resourceProvider.getFile(filePath).createSource();
       if (overlay is AddContentOverlay) {
         fileContentOverlay[source.fullName] = overlay.content;
       } else if (overlay is ChangeContentOverlay) {
         String fileName = source.fullName;
         String oldContents = fileContentOverlay[fileName];
         String newContents;
         if (oldContents == null) {
           // The server should only send a ChangeContentOverlay if there is
           // already an existing overlay for the source.
-          throw new RequestFailure(new RequestError(
-              RequestErrorCode.INVALID_OVERLAY_CHANGE,
-              'Invalid overlay change: no content to change'));
+          throw new RequestFailure(
+              RequestErrorFactory.invalidOverlayChangeNoContent());
         }
         try {
           newContents = SourceEdit.applySequence(oldContents, overlay.edits);
         } on RangeError {
-          throw new RequestFailure(new RequestError(
-              RequestErrorCode.INVALID_OVERLAY_CHANGE,
-              'Invalid overlay change: invalid edit'));
+          throw new RequestFailure(
+              RequestErrorFactory.invalidOverlayChangeInvalidEdit());
         }
         fileContentOverlay[fileName] = newContents;
       } else if (overlay is RemoveContentOverlay) {
         fileContentOverlay[source.fullName] = null;
       }
       contentChanged(filePath);
     });
     return new AnalysisUpdateContentResult();
   }
 
@@ skipping 71 matching lines @@
    */
   void onDone() {}
 
   /**
    * The method that is called when an error has occurred in the analysis
    * server. This method will not be invoked under normal conditions.
    */
   void onError(Object exception, StackTrace stackTrace) {}
 
   /**
+   * Send notifications corresponding to the given description of subscriptions.
+   * The map is keyed by the path of each file for which notifications should be
+   * send and has values representing the list of services associated with the
+   * notifications to send.
+   */
+  void sendNotificationsForSubscriptions(
+      Map<String, List<AnalysisService>> subscriptions);
+
+  /**
    * Start this plugin by listening to the given communication [channel].
    */
   void start(PluginCommunicationChannel channel) {
     _channel = channel;
     _channel.listen(_onRequest, onError: onError, onDone: onDone);
   }
 
   /**
    * Compute the response that should be returned for the given [request], or
    * `null` if the response has already been sent.
@@ skipping 84 matching lines @@
       response = new Response(id,
           error: new RequestError(
               RequestErrorCode.PLUGIN_ERROR, exception.toString(),
               stackTrace: stackTrace.toString()));
     }
     if (response != null) {
       _channel.sendResponse(response);
     }
   }
 }