Add ability for LSP server to send requests to (+ receive responses from) client

Change-Id: Iff1f8f63dc58ef2689ecc44f6e705d6811b12667
Reviewed-on: https://dart-review.googlesource.com/c/86420
Commit-Queue: Danny Tuppeny <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: DanTup

pkg/analysis_server/lib/src/lsp/channel/lsp_byte_stream_channel.dart

@@ -55,7 +55,7 @@ class LspByteStreamServerChannel implements LspServerCommunicationChannel {
   }
 
   @override
-  void listen(void onMessage(IncomingMessage message),
+  void listen(void onMessage(Message message),
       {Function onError, void onDone()}) {
     _input.transform(new LspPacketTransformer()).listen(
       (String data) => _readMessage(data, onMessage),
@@ -71,14 +71,17 @@ class LspByteStreamServerChannel implements LspServerCommunicationChannel {
   void sendNotification(NotificationMessage notification) =>
       _sendLsp(notification.toJson());
 
+  @override
+  void sendRequest(RequestMessage request) => _sendLsp(request.toJson());
+
   @override
   void sendResponse(ResponseMessage response) => _sendLsp(response.toJson());
 
   /**
    * Read a request from the given [data] and use the given function to handle
    * the message.
    */
-  void _readMessage(String data, void onMessage(IncomingMessage request)) {
+  void _readMessage(String data, void onMessage(Message request)) {
     // Ignore any further requests after the communication channel is closed.
     if (_closed.isCompleted) {
       return;
@@ -90,6 +93,8 @@ class LspByteStreamServerChannel implements LspServerCommunicationChannel {
         onMessage(RequestMessage.fromJson(json));
       } else if (NotificationMessage.canParse(json)) {
         onMessage(NotificationMessage.fromJson(json));
+      } else if (ResponseMessage.canParse(json)) {
+        onMessage(ResponseMessage.fromJson(json));
       } else {
         _sendParseError();
       }

pkg/analysis_server/lib/src/lsp/channel/lsp_channel.dart

@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
-import 'package:analysis_server/lsp_protocol/protocol_special.dart';
 import 'package:analysis_server/src/lsp/lsp_analysis_server.dart';
 
 /**
@@ -25,14 +24,19 @@ abstract class LspServerCommunicationChannel {
    * client, invoke the [onDone] function.
    * Only one listener is allowed per channel.
    */
-  void listen(void onMessage(IncomingMessage message),
+  void listen(void onMessage(Message message),
       {Function onError, void onDone()});
 
   /**
    * Send the given [notification] to the client.
    */
   void sendNotification(NotificationMessage notification);
 
+  /**
+   * Send the given [request] to the client.
+   */
+  void sendRequest(RequestMessage request);
+
   /**
    * Send the given [response] to the client.
    */

pkg/analysis_server/lib/src/lsp/lsp_analysis_server.dart

@@ -111,6 +111,10 @@ class LspAnalysisServer extends AbstractAnalysisServer {
 
   ServerStateMessageHandler messageHandler;
 
+  int nextRequestId = 1;
+
+  Map<int, Completer<ResponseMessage>> completers = {};
+
   /**
    * Initialize a newly created server to send and receive messages to the given
    * [channel].
@@ -197,28 +201,66 @@ class LspAnalysisServer extends AbstractAnalysisServer {
             null, new Uri.file(path).toString());
   }
 
+  /// Handles a response from the client by invoking the completer that the
+  /// outbound request created.
+  void handleClientResponse(ResponseMessage message) {
+    // The ID from the client is an Either2<num, String>, though it's not valid
+    // for it to be a string because it should match a request we sent to the
+    // client (and we always use numeric IDs for outgoing requests).
+    message.id.map(
+      (id) {
+        // It's possible that even if we got a numeric ID that it's not valid.
+        // If it's not in our completers list (which is a list of the outstanding
+        // requests we've sent) then show an error.
+        final completer = completers[id];
+        if (completer == null) {
+          showError('Response with ID $id was unexpected');
+        } else {
+          completers.remove(id);
+          completer.complete(message);
+        }
+      },
+      (stringID) {
+        showError('Unexpected String ID for response $stringID');
+      },
+    );
+  }
+
   /**
    * Handle a [message] that was read from the communication channel.
    */
-  void handleMessage(IncomingMessage message) {
+  void handleMessage(Message message) {
     // TODO(dantup): Put in all the things this server is missing, like:
     //     _performance.logRequest(message);
     runZoned(() {
       ServerPerformanceStatistics.serverRequests.makeCurrentWhile(() async {
         try {
-          final result = await messageHandler.handleMessage(message);
-          if (result.isError) {
-            sendErrorResponse(message, result.error);
+          if (message is ResponseMessage) {
+            handleClientResponse(message);
           } else if (message is RequestMessage) {
-            channel.sendResponse(new ResponseMessage(
-                message.id, result.result, null, jsonRpcVersion));
+            final result = await messageHandler.handleMessage(message);
+            if (result.isError) {
+              sendErrorResponse(message, result.error);
+            } else {
+              channel.sendResponse(new ResponseMessage(
+                  message.id, result.result, null, jsonRpcVersion));
+            }
+          } else if (message is NotificationMessage) {
+            final result = await messageHandler.handleMessage(message);
+            if (result.isError) {
+              sendErrorResponse(message, result.error);
+            }
+          } else {
+            showError('Unknown message type');
           }
         } catch (error, stackTrace) {
-          final errorMessage = message is RequestMessage
-              ? 'An error occurred while handling ${message.method} request'
-              : message is NotificationMessage
-                  ? 'An error occurred while handling ${message.method} notification'
-                  : 'Unknown message type';
+          final errorMessage = message is ResponseMessage
+              ? 'An error occurred while handling the response to request ${message.id}'
+              : message is RequestMessage
+                  ? 'An error occurred while handling ${message.method} request'
+                  : message is NotificationMessage
+                      ? 'An error occurred while handling ${message.method} notification'
+                      : 'Unknown message type';
           sendErrorResponse(
               message,
               new ResponseError(
@@ -243,13 +285,17 @@ class LspAnalysisServer extends AbstractAnalysisServer {
     ));
   }
 
-  void sendErrorResponse(IncomingMessage message, ResponseError error) {
+  void sendErrorResponse(Message message, ResponseError error) {
     if (message is RequestMessage) {
       channel.sendResponse(
           new ResponseMessage(message.id, null, error, jsonRpcVersion));
       // Since the LSP client might not show the failed requests to the user,
       // also ensure the error is logged to the client.
       logError(error.message);
+    } else if (message is ResponseMessage) {
+      // For notifications where we couldn't respond with an error, send it as
+      // show instead of log.
+      showError(error.message);
     } else {
       // For notifications where we couldn't respond with an error, send it as
       // show instead of log.
@@ -264,6 +310,24 @@ class LspAnalysisServer extends AbstractAnalysisServer {
     channel.sendNotification(notification);
   }
 
+  /**
+   * Send the given [request] to the client and wait for a response.
+   */
+  Future<ResponseMessage> sendRequest(Method method, Object params) {
+    final requestId = nextRequestId++;
+    final completer = new Completer<ResponseMessage>();
+    completers[requestId] = completer;
+
+    channel.sendRequest(new RequestMessage(
+      Either2<num, String>.t1(requestId),
+      method,
+      params,
+      jsonRpcVersion,
+    ));
+
+    return completer.future;
+  }
+
   /**
    * Send the given [response] to the client.
    */

pkg/analysis_server/lib/src/lsp/lsp_socket_server.dart

@@ -54,7 +54,7 @@ class LspSocketServer {
         new ShowMessageParams(MessageType.Error, error.message),
         jsonRpcVersion,
       ));
-      serverChannel.listen((IncomingMessage message) {
+      serverChannel.listen((Message message) {
         if (message is RequestMessage) {
           serverChannel.sendResponse(
               new ResponseMessage(message.id, null, error, jsonRpcVersion));

pkg/analysis_server/test/lsp/server_abstract.dart

@@ -14,6 +14,7 @@ import 'package:analyzer/source/line_info.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/test_utilities/mock_sdk.dart';
 import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
+import 'package:meta/meta.dart';
 import 'package:test/test.dart';
 
 import '../mocks.dart';
@@ -143,6 +144,22 @@ abstract class AbstractLspAnalysisServerTest with ResourceProviderMixin {
     return notificationFromServer.params as T;
   }
 
+  /// Expects a [method] request from the server after executing [f].
+  Future<RequestMessage> expectRequest(
+    Method method,
+    FutureOr<void> f(), {
+    Duration timeout = const Duration(seconds: 5),
+  }) async {
+    final firstRequest =
+        channel.requestsFromServer.firstWhere((n) => n.method == method);
+    await f();
+
+    final requestFromServer = await firstRequest.timeout(timeout);
+
+    expect(requestFromServer, isNotNull);
+    return requestFromServer;
+  }
+
   /// Sends a request to the server and unwraps the result. Throws if the
   /// response was not successful or returned an error.
   Future<T> expectSuccessfulResponseTo<T>(RequestMessage request) async {
@@ -268,6 +285,49 @@ abstract class AbstractLspAnalysisServerTest with ResourceProviderMixin {
     return expectSuccessfulResponseTo<SignatureHelp>(request);
   }
 
+  /// Executes [f] then waits for a request of type [method] from the server which
+  /// is passed to [handler] to process, then waits for (and returns) the
+  /// response to the original request.
+  ///
+  /// This is used for testing things like code actions, where the client initiates
+  /// a request but the server does not respond to it until it's sent its own
+  /// request to the client and it recieved a response.
+  ///
+  ///     Client                                 Server
+  ///     1. |- Req: textDocument/codeAction      ->
+  ///     1. <- Resp: textDocument/codeAction     -|
+  ///
+  ///     2. |- Req: workspace/executeCommand  ->
+  ///           3. <- Req: textDocument/applyEdits  -|
+  ///           3. |- Resp: textDocument/applyEdits ->
+  ///     2. <- Resp: workspace/executeCommand -|
+  ///
+  /// Request 2 from the client is not responded to until the server has its own
+  /// response to the request it sends (3).
+  Future<T> handleExpectedRequest<T, R, RR>(
+    Method method,
+    Future<T> f(), {
+    @required FutureOr<RR> handler(R params),
+    Duration timeout = const Duration(seconds: 5),
+  }) async {
+    FutureOr<T> outboundRequest;
+
+    // Run [f] and wait for the incoming request from the server.
+    final incomingRequest = await expectRequest(method, () {
+      // Don't return/await the response yet, as this may not complete until
+      // after we have handled the request that comes from the server.
+      outboundRequest = f();
+    });
+
+    // Handle the request from the server and send the response back.
+    final clientsResponse = await handler(incomingRequest.params as R);
+    respondTo(incomingRequest, clientsResponse);
+
+    // Return a future that completes when the response to the original request
+    // (from [f]) returns.
+    return outboundRequest;
+  }
+
   /// A helper that initializes the server with common values, since the server
   /// will reject any other requests until it is initialized.
   /// Capabilities are overridden by providing JSON to avoid having to construct
@@ -368,6 +428,13 @@ abstract class AbstractLspAnalysisServerTest with ResourceProviderMixin {
     );
   }
 
+  /// Sends [responseParams] to the server as a successful response to
+  /// a server-initiated [request].
+  void respondTo<T>(RequestMessage request, T responseParams) async {
+    channel.sendResponseToServer(
+        new ResponseMessage(request.id, responseParams, null, jsonRpcVersion));
+  }
+
   void setUp() {
     channel = new MockLspServerChannel(debugPrintCommunication);
     // Create an SDK in the mock file system.