Add context information to driver and add hooks for plugin management

pkg/analysis_server/lib/src/plugin/plugin_manager.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 'dart:async';
 import 'dart:collection';
 import 'dart:io' show Platform;
 
 import 'package:analysis_server/src/plugin/notification_manager.dart';
+import 'package:analyzer/context/context_root.dart' as analyzer;
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/src/generated/bazel.dart';
 import 'package:analyzer/src/generated/gn.dart';
 import 'package:analyzer_plugin/channel/channel.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart';
 import 'package:analyzer_plugin/src/channel/isolate_channel.dart';
 import 'package:analyzer_plugin/src/protocol/protocol_internal.dart';
 import 'package:convert/convert.dart';
@@ skipping 30 matching lines @@
 
   /**
    * The instrumentation service that is being used by the analysis server.
    */
   final InstrumentationService instrumentationService;
 
   /**
    * The context roots that are currently using the results produced by the
    * plugin.
    */
-  Set<ContextRoot> contextRoots = new HashSet<ContextRoot>();
+  Set<analyzer.ContextRoot> contextRoots = new HashSet<analyzer.ContextRoot>();
 
   /**
    * The current execution of the plugin, or `null` if the plugin is not
    * currently being executed.
    */
   PluginSession currentSession;
 
   /**
    * Initialize the newly created information about a plugin.
    */
   PluginInfo(this.path, this.executionPath, this.packagesPath,
       this.notificationManager, this.instrumentationService);
 
   /**
    * Add the given [contextRoot] to the set of context roots being analyzed by
    * this plugin.
    */
-  void addContextRoot(ContextRoot contextRoot) {
+  void addContextRoot(analyzer.ContextRoot contextRoot) {
     if (contextRoots.add(contextRoot)) {
       _updatePluginRoots();
     }
   }
 
   /**
    * Remove the given [contextRoot] from the set of context roots being analyzed
    * by this plugin.
    */
-  void removeContextRoot(ContextRoot contextRoot) {
+  void removeContextRoot(analyzer.ContextRoot contextRoot) {
     if (contextRoots.remove(contextRoot)) {
       _updatePluginRoots();
     }
   }
 
   /**
    * Start a new isolate that is running the plugin. Return the state object
    * used to interact with the plugin.
    */
   Future<PluginSession> start(String byteStorePath) async {
@@ skipping 15 matching lines @@
     Future<Null> doneFuture = currentSession.stop();
     currentSession = null;
     return doneFuture;
   }
 
   /**
    * Update the context roots that the plugin should be analyzing.
    */
   void _updatePluginRoots() {
     if (currentSession != null) {
-      AnalysisSetContextRootsParams params =
-          new AnalysisSetContextRootsParams(contextRoots.toList());
+      AnalysisSetContextRootsParams params = new AnalysisSetContextRootsParams(
+          contextRoots
+              .map((analyzer.ContextRoot contextRoot) =>
+                  new ContextRoot(contextRoot.root, contextRoot.exclude))
+              .toList());
       currentSession.sendRequest(params);
     }
   }
 }
 
 /**
  * An object used to manage the currently running plugins.
  */
 class PluginManager {
   /**
@@ skipping 28 matching lines @@
    */
   PluginManager(this.resourceProvider, this.byteStorePath,
       this.notificationManager, this.instrumentationService);
 
   /**
    * Add the plugin with the given [path] to the list of plugins that should be
    * used when analyzing code for the given [contextRoot]. If the plugin had not
    * yet been started, then it will be started by this method.
    */
   Future<Null> addPluginToContextRoot(
-      ContextRoot contextRoot, String path) async {
+      analyzer.ContextRoot contextRoot, String path) async {
     PluginInfo plugin = _pluginMap[path];
     if (plugin == null) {
       List<String> pluginPaths = _pathsFor(path);
       plugin = new PluginInfo(path, pluginPaths[0], pluginPaths[1],
           notificationManager, instrumentationService);
       _pluginMap[path] = plugin;
       if (pluginPaths[0] != null) {
         PluginSession session = await plugin.start(byteStorePath);
         session.onDone.then((_) {
           _pluginMap.remove(path);
         });
       }
     }
     plugin.addContextRoot(contextRoot);
   }
 
   /**
    * Broadcast a request built from the given [params] to all of the plugins
    * that are currently associated with the given [contextRoot]. Return a list
    * containing futures that will complete when each of the plugins have sent a
    * response.
    */
   List<Future<Response>> broadcast(
-      ContextRoot contextRoot, RequestParams params) {
+      analyzer.ContextRoot contextRoot, RequestParams params) {
     List<PluginInfo> plugins = pluginsForContextRoot(contextRoot);
     return plugins
         .map((PluginInfo plugin) => plugin.currentSession?.sendRequest(params))
         .toList();
   }
 
   /**
    * Return a list of all of the plugins that are currently associated with the
    * given [contextRoot].
    */
   @visibleForTesting
-  List<PluginInfo> pluginsForContextRoot(ContextRoot contextRoot) {
+  List<PluginInfo> pluginsForContextRoot(analyzer.ContextRoot contextRoot) {
     List<PluginInfo> plugins = <PluginInfo>[];
     for (PluginInfo plugin in _pluginMap.values) {
       if (plugin.contextRoots.contains(contextRoot)) {
         plugins.add(plugin);
       }
     }
     return plugins;
   }
 
   /**
    * The given [contextRoot] is no longer being analyzed.
    */
-  void removedContextRoot(ContextRoot contextRoot) {
+  void removedContextRoot(analyzer.ContextRoot contextRoot) {
     List<PluginInfo> plugins = _pluginMap.values.toList();
     for (PluginInfo plugin in plugins) {
       plugin.removeContextRoot(contextRoot);
       if (plugin.contextRoots.isEmpty) {
         _pluginMap.remove(plugin.path);
         plugin.stop();
       }
     }
   }
 
@@ skipping 256 matching lines @@
   Future<Null> stop() {
     if (channel == null) {
       throw new StateError('Cannot stop a plugin that is not running.');
     }
     // TODO(brianwilkerson) Ensure that the isolate is killed if it does not
     // terminate normally.
     sendRequest(new PluginShutdownParams());
     return pluginStoppedCompleter.future;
   }
 }