Merge pull request #1126 from ahoppen/ahoppen/jsonrpc-strict-concurrency

Make the `LanguageServerProtocolJSONRPC` module build with strict concurrency enabled

Author: ahoppen

Package.swift

@@ -119,7 +119,8 @@ let package = Package(
         "LanguageServerProtocol",
         "LSPLogging",
       ],
-      exclude: ["CMakeLists.txt"]
+      exclude: ["CMakeLists.txt"],
+      swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]
     ),
 
     .testTarget(

Sources/LSPLogging/CustomLogStringConvertible.swift

@@ -15,7 +15,7 @@ import Foundation
 
 /// An object that can printed for logging and also offers a redacted description
 /// when logging in contexts in which private information shouldn't be captured.
-public protocol CustomLogStringConvertible: CustomStringConvertible {
+public protocol CustomLogStringConvertible: CustomStringConvertible, Sendable {
   /// A full description of the object.
   var description: String { get }
 
@@ -30,7 +30,7 @@ public protocol CustomLogStringConvertible: CustomStringConvertible {
 /// There currently is no way to get equivalent functionality in pure Swift. We
 /// thus pass this object to OSLog, which just forwards to `description` or
 /// `redactedDescription` of an object that implements `CustomLogStringConvertible`.
-public class CustomLogStringConvertibleWrapper: NSObject {
+public final class CustomLogStringConvertibleWrapper: NSObject, Sendable {
   private let underlyingObject: any CustomLogStringConvertible
 
   fileprivate init(_ underlyingObject: any CustomLogStringConvertible) {

Sources/LSPTestSupport/TestJSONRPCConnection.swift

@@ -20,55 +20,68 @@ import class Foundation.Pipe
 public final class TestJSONRPCConnection {
   public let clientToServer: Pipe = Pipe()
   public let serverToClient: Pipe = Pipe()
-  public let client: TestMessageHandler
-  public let clientConnection: JSONRPCConnection
+
+  /// Mocks a client (aka. editor) that can send requests to the LSP server.
+  public let client: TestClient
+
+  /// The connection with which the client can send requests and notifications to the LSP server and using which it
+  /// receives replies to the requests.
+  public let clientToServerConnection: JSONRPCConnection
+
+  /// Mocks an LSP server that handles requests from the client.
   public let server: TestServer
-  public let serverConnection: JSONRPCConnection
+
+  /// The connection with which the server can send requests and notifications to the client and using which it
+  /// receives replies to the requests.
+  public let serverToClientConnection: JSONRPCConnection
 
   public init(allowUnexpectedNotification: Bool = true) {
-    clientConnection = JSONRPCConnection(
+    clientToServerConnection = JSONRPCConnection(
       name: "client",
       protocol: testMessageRegistry,
       inFD: serverToClient.fileHandleForReading,
       outFD: clientToServer.fileHandleForWriting
     )
 
-    serverConnection = JSONRPCConnection(
+    serverToClientConnection = JSONRPCConnection(
       name: "server",
       protocol: testMessageRegistry,
       inFD: clientToServer.fileHandleForReading,
       outFD: serverToClient.fileHandleForWriting
     )
 
-    client = TestMessageHandler(server: clientConnection, allowUnexpectedNotification: allowUnexpectedNotification)
-    server = TestServer(client: serverConnection)
+    client = TestClient(
+      connectionToServer: clientToServerConnection,
+      allowUnexpectedNotification: allowUnexpectedNotification
+    )
+    server = TestServer(client: serverToClientConnection)
 
-    clientConnection.start(receiveHandler: client) {
+    clientToServerConnection.start(receiveHandler: client) {
       // FIXME: keep the pipes alive until we close the connection. This
       // should be fixed systemically.
       withExtendedLifetime(self) {}
     }
-    serverConnection.start(receiveHandler: server) {
+    serverToClientConnection.start(receiveHandler: server) {
       // FIXME: keep the pipes alive until we close the connection. This
       // should be fixed systemically.
       withExtendedLifetime(self) {}
     }
   }
 
   public func close() {
-    clientConnection.close()
-    serverConnection.close()
+    clientToServerConnection.close()
+    serverToClientConnection.close()
   }
 }
 
 public struct TestLocalConnection {
-  public let client: TestMessageHandler
-  public let clientConnection: LocalConnection = .init()
+  public let client: TestClient
+  public let clientConnection: LocalConnection = LocalConnection()
   public let server: TestServer
-  public let serverConnection: LocalConnection = .init()
+  public let serverConnection: LocalConnection = LocalConnection()
 
   public init(allowUnexpectedNotification: Bool = true) {
-    client = TestMessageHandler(server: serverConnection, allowUnexpectedNotification: allowUnexpectedNotification)
+    client = TestClient(connectionToServer: serverConnection, allowUnexpectedNotification: allowUnexpectedNotification)
     server = TestServer(client: clientConnection)
 
     clientConnection.start(handler: client)
@@ -81,18 +94,18 @@ public struct TestLocalConnection {
   }
 }
 
-public actor TestMessageHandler: MessageHandler {
-  /// The connection to the language client.
-  public let server: Connection
+public actor TestClient: MessageHandler {
+  /// The connection to the LSP server.
+  public let connectionToServer: Connection
 
   private let messageHandlingQueue = AsyncQueue<Serial>()
 
   private var oneShotNotificationHandlers: [((Any) -> Void)] = []
 
   private let allowUnexpectedNotification: Bool
 
-  public init(server: Connection, allowUnexpectedNotification: Bool = true) {
-    self.server = server
+  public init(connectionToServer: Connection, allowUnexpectedNotification: Bool = true) {
+    self.connectionToServer = connectionToServer
     self.allowUnexpectedNotification = allowUnexpectedNotification
   }
 
@@ -106,7 +119,7 @@ public actor TestMessageHandler: MessageHandler {
   }
 
   /// The LSP server sent a notification to the client. Handle it.
-  public nonisolated func handle(_ notification: some NotificationType, from clientID: ObjectIdentifier) {
+  public nonisolated func handle(_ notification: some NotificationType) {
     messageHandlingQueue.async {
       await self.handleNotificationImpl(notification)
     }
@@ -125,25 +138,22 @@ public actor TestMessageHandler: MessageHandler {
   public nonisolated func handle<Request: RequestType>(
     _ request: Request,
     id: RequestID,
-    from clientID: ObjectIdentifier,
     reply: @escaping (LSPResult<Request.Response>) -> Void
   ) {
     reply(.failure(.methodNotFound(Request.method)))
   }
-}
 
-extension TestMessageHandler: Connection {
   /// Send a notification to the LSP server.
   public nonisolated func send(_ notification: some NotificationType) {
-    server.send(notification)
+    connectionToServer.send(notification)
   }
 
   /// Send a request to the LSP server and (asynchronously) receive a reply.
   public nonisolated func send<Request: RequestType>(
     _ request: Request,
     reply: @escaping (LSPResult<Request.Response>) -> Void
   ) -> RequestID {
-    return server.send(request, reply: reply)
+    return connectionToServer.send(request, reply: reply)
   }
 }
 
@@ -154,35 +164,36 @@ public final class TestServer: MessageHandler {
     self.client = client
   }
 
-  public func handle(_ params: some NotificationType, from clientID: ObjectIdentifier) {
-    if params is EchoNotification {
-      self.client.send(params)
+  /// The client sent a notification to the server. Handle it.
+  public func handle(_ notification: some NotificationType) {
+    if notification is EchoNotification {
+      self.client.send(notification)
     } else {
       fatalError("Unhandled notification")
     }
   }
 
-  public func handle<R: RequestType>(
-    _ params: R,
+  /// The client sent a request to the server. Handle it.
+  public func handle<Request: RequestType>(
+    _ request: Request,
     id: RequestID,
-    from clientID: ObjectIdentifier,
-    reply: @escaping (LSPResult<R.Response>) -> Void
+    reply: @escaping (LSPResult<Request.Response>) -> Void
   ) {
-    if let params = params as? EchoRequest {
-      reply(.success(params.string as! R.Response))
-    } else if let params = params as? EchoError {
+    if let params = request as? EchoRequest {
+      reply(.success(params.string as! Request.Response))
+    } else if let params = request as? EchoError {
       if let code = params.code {
         reply(.failure(ResponseError(code: code, message: params.message!)))
       } else {
-        reply(.success(VoidResponse() as! R.Response))
+        reply(.success(VoidResponse() as! Request.Response))
       }
     } else {
       fatalError("Unhandled request")
     }
   }
 }
 
-// MARK: Test requests.
+// MARK: Test requests
 
 private let testMessageRegistry = MessageRegistry(
   requests: [EchoRequest.self, EchoError.self],

Sources/LanguageServerProtocol/Connection.swift

@@ -20,20 +20,20 @@ public protocol Connection: AnyObject, Sendable {
 
   /// Send a request and (asynchronously) receive a reply.
   func send<Request: RequestType>(
-    _: Request,
-    reply: @escaping (LSPResult<Request.Response>) -> Void
+    _ request: Request,
+    reply: @escaping @Sendable (LSPResult<Request.Response>) -> Void
   ) -> RequestID
 }
 
 /// An abstract message handler, such as a language server or client.
-public protocol MessageHandler: AnyObject {
+public protocol MessageHandler: AnyObject, Sendable {
 
   /// Handle a notification without a reply.
   ///
   /// The method should return as soon as the notification has been sufficiently
   /// handled to avoid out-of-order requests, e.g. once the notification has
   /// been forwarded to clangd.
-  func handle(_ params: some NotificationType, from clientID: ObjectIdentifier)
+  func handle(_ notification: some NotificationType)
 
   /// Handle a request and (asynchronously) receive a reply.
   ///
@@ -42,9 +42,8 @@ public protocol MessageHandler: AnyObject {
   /// request has been sent to sourcekitd. The actual semantic computation
   /// should occur after the method returns and report the result via `reply`.
   func handle<Request: RequestType>(
-    _ params: Request,
+    _ request: Request,
     id: RequestID,
-    from clientID: ObjectIdentifier,
     reply: @escaping (LSPResult<Request.Response>) -> Void
   )
 }
@@ -63,7 +62,7 @@ public protocol MessageHandler: AnyObject {
 /// ```
 ///
 /// - Note: Unchecked sendable conformance because shared state is guarded by `queue`.
-public final class LocalConnection: @unchecked Sendable {
+public final class LocalConnection: Connection, @unchecked Sendable {
 
   enum State {
     case ready, started, closed
@@ -104,11 +103,9 @@ public final class LocalConnection: @unchecked Sendable {
       return .number(_nextRequestID)
     }
   }
-}
 
-extension LocalConnection: Connection {
   public func send<Notification>(_ notification: Notification) where Notification: NotificationType {
-    self.handler?.handle(notification, from: ObjectIdentifier(self))
+    self.handler?.handle(notification)
   }
 
   public func send<Request: RequestType>(
@@ -123,7 +120,7 @@ extension LocalConnection: Connection {
     }
 
     precondition(self.state == .started)
-    handler.handle(request, id: id, from: ObjectIdentifier(self)) { result in
+    handler.handle(request, id: id) { result in
       reply(result)
     }
 

Sources/LanguageServerProtocol/Message.swift

@@ -26,7 +26,6 @@ public protocol _RequestType: MessageType {
   func _handle(
     _ handler: MessageHandler,
     id: RequestID,
-    connection: Connection,
     reply: @escaping (LSPResult<ResponseType>, RequestID) -> Void
   )
 }
@@ -52,18 +51,17 @@ extension RequestType {
   public func _handle(
     _ handler: MessageHandler,
     id: RequestID,
-    connection: Connection,
     reply: @escaping (LSPResult<ResponseType>, RequestID) -> Void
   ) {
-    handler.handle(self, id: id, from: ObjectIdentifier(connection)) { response in
+    handler.handle(self, id: id) { response in
       reply(response.map({ $0 as ResponseType }), id)
     }
   }
 }
 
 extension NotificationType {
-  public func _handle(_ handler: MessageHandler, connection: Connection) {
-    handler.handle(self, from: ObjectIdentifier(connection))
+  public func _handle(_ handler: MessageHandler) {
+    handler.handle(self)
   }
 }