Revert asyncificaiton changes

The asyncification changes caused some non-deterministic test failures. I believe that some of these are due to race conditions that are the result of the partial transition to actors.

Instead of merging the asyncification piece by piece, I will collect the changes asyncification changes in a branch and then qualify that branch througougly (running CI multiple times) before merging it into `main`.

Author: ahoppen

Sources/LSPLogging/Logging.swift

@@ -62,22 +62,6 @@ public func orLog<R>(
   }
 }
 
-/// Like `try?`, but logs the error on failure.
-public func orLog<R>(
-  _ prefix: String = "",
-  level: LogLevel = .default,
-  logger: Logger = Logger.shared,
-  _ block: () async throws -> R?) async -> R?
-{
-  do {
-    return try await block()
-  } catch {
-    logger.log("\(prefix)\(prefix.isEmpty ? "" : " ")\(error)", level: level)
-    return nil
-  }
-}
-
-
 /// Logs the time that the given block takes to execute in milliseconds.
 public func logExecutionTime<R>(
   _ prefix: String = #function,

Sources/LSPTestSupport/AssertNoThrow.swift

@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import XCTest
+
+/// Same as `XCTAssertThrows` but executes the trailing closure.
+public func assertNoThrow<T>(_ expression: () throws -> T, _ message: @autoclosure () -> String = "", file: StaticString = #filePath, line: UInt = #line) {
+  XCTAssertNoThrow(try expression(), message(), file: file, line: line)
+}

Sources/LSPTestSupport/Assertions.swift

@@ -1,5 +1,4 @@
 add_library(LanguageServerProtocol STATIC
-  AsyncQueue.swift
   Cancellation.swift
   Connection.swift
   CustomCodable.swift

Sources/LanguageServerProtocol/AsyncQueue.swift

@@ -42,19 +42,10 @@ extension Connection {
 public protocol MessageHandler: AnyObject {
 
   /// 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) async
+  func handle(_ params: some NotificationType, from clientID: ObjectIdentifier)
 
   /// Handle a request and (asynchronously) receive a reply.
-  ///
-  /// The method should return as soon as the request has been sufficiently
-  /// handled to avoid out-of-order requests, e.g. once the corresponding
-  /// 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, id: RequestID, from clientID: ObjectIdentifier, reply: @escaping (LSPResult<Request.Response>) -> Void) async
+  func handle<Request: RequestType>(_ params: Request, id: RequestID, from clientID: ObjectIdentifier, reply: @escaping (LSPResult<Request.Response>) -> Void)
 }
 
 /// A connection between two message handlers in the same process.
@@ -75,20 +66,8 @@ public final class LocalConnection {
     case ready, started, closed
   }
 
-  /// The queue guarding `_nextRequestID`.
   let queue: DispatchQueue = DispatchQueue(label: "local-connection-queue")
 
-  /// The queue on which all messages (notifications, requests, responses) are
-  /// handled.
-  ///
-  /// The queue is blocked until the message has been sufficiently handled to
-  /// avoid out-of-order handling of messages. For sourcekitd, this means that
-  /// a request has been sent to sourcekitd and for clangd, this means that we
-  /// have forwarded the request to clangd.
-  ///
-  /// The actual semantic handling of the message happens off this queue.
-  let messageHandlingQueue: AsyncQueue = AsyncQueue()
-
   var _nextRequestID: Int = 0
 
   var state: State = .ready
@@ -125,34 +104,22 @@ public final class LocalConnection {
 
 extension LocalConnection: Connection {
   public func send<Notification>(_ notification: Notification) where Notification: NotificationType {
-    messageHandlingQueue.async {
-      await self.handler?.handle(notification, from: ObjectIdentifier(self))
-    }
+    handler?.handle(notification, from: ObjectIdentifier(self))
   }
 
-  public func send<Request: RequestType>(
-    _ request: Request,
-    queue: DispatchQueue,
-    reply: @escaping (LSPResult<Request.Response>) -> Void
-  ) -> RequestID {
+  public func send<Request>(_ request: Request, queue: DispatchQueue, reply: @escaping (LSPResult<Request.Response>) -> Void) -> RequestID where Request: RequestType {
     let id = nextRequestID()
+    guard let handler = handler else {
+      queue.async { reply(.failure(.serverCancelled)) }
+      return id
+    }
 
-    messageHandlingQueue.async {
-      guard let handler = self.handler else {
-        queue.async {
-          reply(.failure(.serverCancelled))
-        }
-        return
-      }
-
-      precondition(self.state == .started)
-      await handler.handle(request, id: id, from: ObjectIdentifier(self)) { result in
-        queue.async {
-          reply(result)
-        }
+    precondition(state == .started)
+    handler.handle(request, id: id, from: ObjectIdentifier(self)) { result in
+      queue.async {
+        reply(result)
       }
     }
-
     return id
   }
 }

Sources/LanguageServerProtocol/CMakeLists.txt

@@ -28,7 +28,7 @@ public protocol _RequestType: MessageType {
     id: RequestID,
     connection: Connection,
     reply: @escaping (LSPResult<ResponseType>, RequestID) -> Void
-  ) async
+  )
 }
 
 /// A request, which must have a unique `method` name as well as an associated response type.
@@ -54,16 +54,16 @@ extension RequestType {
     id: RequestID,
     connection: Connection,
     reply: @escaping (LSPResult<ResponseType>, RequestID) -> Void
-  ) async {
-    await handler.handle(self, id: id, from: ObjectIdentifier(connection)) { response in
+  ) {
+    handler.handle(self, id: id, from: ObjectIdentifier(connection)) { response in
       reply(response.map({ $0 as ResponseType }), id)
     }
   }
 }
 
 extension NotificationType {
-  public func _handle(_ handler: MessageHandler, connection: Connection) async {
-    await handler.handle(self, from: ObjectIdentifier(connection))
+  public func _handle(_ handler: MessageHandler, connection: Connection) {
+    handler.handle(self, from: ObjectIdentifier(connection))
   }
 }
 

Sources/LanguageServerProtocol/Connection.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 public typealias CodeActionProviderCompletion = (LSPResult<[CodeAction]>) -> Void
-public typealias CodeActionProvider = (CodeActionRequest, @escaping CodeActionProviderCompletion) async -> Void
+public typealias CodeActionProvider = (CodeActionRequest, @escaping CodeActionProviderCompletion) -> Void
 
 /// Request for returning all possible code actions for a given text document and range.
 ///