Add support for built-in plugins

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/src/util/glob.dart';
 import 'package:analyzer_plugin/channel/channel.dart';
 import 'package:analyzer_plugin/protocol/protocol.dart';
 import 'package:analyzer_plugin/protocol/protocol_constants.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';
 import 'package:crypto/crypto.dart';
 import 'package:meta/meta.dart';
-import 'package:path/path.dart' as path;
 import 'package:watcher/watcher.dart' as watcher;
 
 /**
- * Information about a single plugin.
+ * Information about a plugin that is built-in.
  */
-class PluginInfo {
+class BuiltInPluginInfo extends PluginInfo {
+  /**
+   * The entry point function that will be executed in the plugin's isolate.
+   */
+  final EntryPoint entryPoint;
+
+  @override
+  final String pluginId;
+
+  /**
+   * Initialize a newly created built-in plugin.
+   */
+  BuiltInPluginInfo(
+      this.entryPoint,
+      this.pluginId,
+      NotificationManager notificationManager,
+      InstrumentationService instrumentationService)
+      : super(notificationManager, instrumentationService);
+
+  @override
+  ServerCommunicationChannel _createChannel() {
+    return new ServerIsolateChannel.builtIn(
+        entryPoint, pluginId, instrumentationService);
+  }
+}
+
+/**
+ * Information about a plugin that was discovered.
+ */
+class DiscoveredPluginInfo extends PluginInfo {
   /**
    * The path to the root directory of the definition of the plugin on disk (the
    * directory containing the 'pubspec.yaml' file and the 'bin' directory).
    */
   final String path;
 
   /**
    * The path to the 'plugin.dart' file that will be executed in an isolate.
    */
   final String executionPath;
 
   /**
    * The path to the '.packages' file used to control the resolution of
    * 'package:' URIs.
    */
   final String packagesPath;
 
   /**
+   * Initialize the newly created information about a plugin.
+   */
+  DiscoveredPluginInfo(
+      this.path,
+      this.executionPath,
+      this.packagesPath,
+      NotificationManager notificationManager,
+      InstrumentationService instrumentationService)
+      : super(notificationManager, instrumentationService);
+
+  @override
+  String get pluginId => path;
+
+  @override
+  ServerCommunicationChannel _createChannel() {
+    return new ServerIsolateChannel.discovered(
+        new Uri.file(executionPath, windows: Platform.isWindows),
+        new Uri.file(packagesPath, windows: Platform.isWindows),
+        instrumentationService);
+  }
+}
+
+/**
+ * Information about a single plugin.
+ */
+abstract class PluginInfo {
+  /**
    * The object used to manage the receiving and sending of notifications.
    */
   final NotificationManager notificationManager;
 
   /**
    * 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<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);
+  PluginInfo(this.notificationManager, this.instrumentationService);
 
   /**
    * Return the data known about this plugin.
    */
   PluginData get data =>
-      new PluginData(path, currentSession?.name, currentSession?.version);
+      new PluginData(pluginId, currentSession?.name, currentSession?.version);
+
+  /**
+   * Return the id of this plugin, used to identify the plugin to users.
+   */
+  String get pluginId;
 
   /**
    * Add the given [contextRoot] to the set of context roots being analyzed by
    * this plugin.
    */
   void addContextRoot(analyzer.ContextRoot contextRoot) {
     if (contextRoots.add(contextRoot)) {
       _updatePluginRoots();
     }
   }
 
   /**
+   * Return `true` if at least one of the context roots being analyzed contains
+   * the file with the given [filePath].
+   */
+  bool isAnalyzing(String filePath) {
+    for (var contextRoot in contextRoots) {
+      if (contextRoot.containsFile(filePath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
    * Remove the given [contextRoot] from the set of context roots being analyzed
    * by this plugin.
    */
   void removeContextRoot(analyzer.ContextRoot contextRoot) {
     if (contextRoots.remove(contextRoot)) {
       _updatePluginRoots();
     }
   }
 
   /**
@@ skipping 27 matching lines @@
   Future<Null> stop() {
     if (currentSession == null) {
       throw new StateError('Cannot stop a plugin that is not running.');
     }
     Future<Null> doneFuture = currentSession.stop();
     currentSession = null;
     return doneFuture;
   }
 
   /**
+   * Create the channel used to communicate with the server.
+   */
+  ServerCommunicationChannel _createChannel();
+
+  /**
    * Update the context roots that the plugin should be analyzing.
    */
   void _updatePluginRoots() {
     if (currentSession != null) {
       AnalysisSetContextRootsParams params = new AnalysisSetContextRootsParams(
           contextRoots
               .map((analyzer.ContextRoot contextRoot) =>
                   new ContextRoot(contextRoot.root, contextRoot.exclude))
               .toList());
       currentSession.sendRequest(params);
@@ skipping 66 matching lines @@
    */
   Future<Null> addPluginToContextRoot(
       analyzer.ContextRoot contextRoot, String path) async {
     PluginInfo plugin = _pluginMap[path];
     bool isNew = plugin == null;
     if (isNew) {
       List<String> pluginPaths = _pathsFor(path);
       if (pluginPaths == null) {
         return;
       }
-      plugin = new PluginInfo(path, pluginPaths[0], pluginPaths[1],
+      plugin = new DiscoveredPluginInfo(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);
@@ skipping 34 matching lines @@
    * response.
    */
   Future<List<Future<Response>>> broadcastWatchEvent(
       watcher.WatchEvent watchEvent) async {
     String filePath = watchEvent.path;
 
     /**
      * Return `true` if the given glob [pattern] matches the file being watched.
      */
     bool matches(String pattern) =>
-        new Glob(path.separator, pattern).matches(filePath);
+        new Glob(resourceProvider.pathContext.separator, pattern)
+            .matches(filePath);
 
     WatchEvent event = null;
     List<Future<Response>> responses = <Future<Response>>[];
     for (PluginInfo plugin in _pluginMap.values) {
       PluginSession session = plugin.currentSession;
       if (session != null &&
-          path.isWithin(plugin.path, filePath) &&
+          plugin.isAnalyzing(filePath) &&
           session.interestingFiles.any(matches)) {
         event ??= _convertWatchEvent(watchEvent);
         AnalysisHandleWatchEventsParams params =
             new AnalysisHandleWatchEventsParams([event]);
         responses.add(session.sendRequest(params));
       }
     }
     return responses;
   }
 
@@ skipping 15 matching lines @@
     return plugins;
   }
 
   /**
    * The given [contextRoot] is no longer being analyzed.
    */
   void removedContextRoot(analyzer.ContextRoot contextRoot) {
     List<PluginInfo> plugins = _pluginMap.values.toList();
     for (PluginInfo plugin in plugins) {
       plugin.removeContextRoot(contextRoot);
-      if (plugin.contextRoots.isEmpty) {
+      if (plugin is DiscoveredPluginInfo && plugin.contextRoots.isEmpty) {
         _pluginMap.remove(plugin.path);
         plugin.stop();
       }
     }
   }
 
   /**
    * Send a request based on the given [params] to existing plugins to set the
    * priority files to those specified by the [params]. As a side-effect, record
    * the parameters so that they can be sent to any newly started plugins.
@@ skipping 230 matching lines @@
    */
   void handleNotification(Notification notification) {
     if (notification.event == PLUGIN_NOTIFICATION_ERROR) {
       PluginErrorParams params =
           new PluginErrorParams.fromNotification(notification);
       if (params.isFatal) {
         info.stop();
         stop();
       }
     }
-    info.notificationManager.handlePluginNotification(info.path, notification);
+    info.notificationManager
+        .handlePluginNotification(info.pluginId, notification);
   }
 
   /**
    * Handle the fact that the plugin has stopped.
    */
   void handleOnDone() {
     channel.close();
     channel = null;
     pluginStoppedCompleter.complete(null);
   }
@@ skipping 47 matching lines @@
   Future<bool> start(String byteStorePath) async {
     if (channel != null) {
       throw new StateError('Cannot start a plugin that is already running.');
     }
     if (byteStorePath == null || byteStorePath.isEmpty) {
       throw new StateError('Missing byte store path');
     }
     if (!isCompatible) {
       return false;
     }
-    channel = new ServerIsolateChannel(
-        new Uri.file(info.executionPath, windows: Platform.isWindows),
-        new Uri.file(info.packagesPath, windows: Platform.isWindows),
-        info.instrumentationService);
+    channel = info._createChannel();
     await channel.listen(handleResponse, handleNotification,
         onDone: handleOnDone, onError: handleOnError);
     if (channel == null) {
       // If there is an error when starting the isolate, the channel will invoke
       // handleOnDone, which will cause `channel` to be set to `null`.
       return false;
     }
     Response response = await sendRequest(
         new PluginVersionCheckParams(byteStorePath ?? '', '1.0.0-alpha.0'));
     PluginVersionCheckResult result =
@@ skipping 16 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;
   }
 }