Add Sendable annotations to SKSupport

Author: ahoppen

Package.swift

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

Sources/LanguageServerProtocol/Connection.swift

@@ -13,7 +13,7 @@
 import Dispatch
 
 /// An abstract connection, allow messages to be sent to a (potentially remote) `MessageHandler`.
-public protocol Connection: AnyObject {
+public protocol Connection: AnyObject, Sendable {
 
   /// Send a notification without a reply.
   func send(_ notification: some NotificationType)
@@ -61,7 +61,9 @@ public protocol MessageHandler: AnyObject {
 /// conn.send(...) // handled by server
 /// conn.close()
 /// ```
-public final class LocalConnection {
+///
+/// - Note: Unchecked sendable conformance because shared state is guarded by `queue`.
+public final class LocalConnection: @unchecked Sendable {
 
   enum State {
     case ready, started, closed

Sources/SKSupport/AsyncQueue.swift

@@ -34,7 +34,7 @@ fileprivate extension NSLock {
 }
 
 /// A type that is able to track dependencies between tasks.
-public protocol DependencyTracker {
+public protocol DependencyTracker: Sendable {
   /// Whether the task described by `self` needs to finish executing before
   /// `other` can start executing.
   func isDependency(of other: Self) -> Bool
@@ -48,29 +48,47 @@ public struct Serial: DependencyTracker {
   }
 }
 
-/// A queue that allows the execution of asynchronous blocks of code.
-public final class AsyncQueue<TaskMetadata: DependencyTracker> {
-  private struct PendingTask {
-    /// The task that is pending.
-    let task: any AnyTask
+private struct PendingTask<TaskMetadata: Sendable>: Sendable {
+  /// The task that is pending.
+  let task: any AnyTask
 
-    let metadata: TaskMetadata
+  let metadata: TaskMetadata
 
-    /// A unique value used to identify the task. This allows tasks to get
-    /// removed from `pendingTasks` again after they finished executing.
-    let id: UUID
-  }
+  /// A unique value used to identify the task. This allows tasks to get
+  /// removed from `pendingTasks` again after they finished executing.
+  let id: UUID
+}
 
+/// A list of pending tasks that can be sent across actor boundaries and is guarded by a lock.
+///
+/// - Note: Unchecked sendable because the tasks are being protected by a lock.
+private class PendingTasks<TaskMetadata: Sendable>: @unchecked Sendable {
   ///  Lock guarding `pendingTasks`.
-  private let pendingTasksLock = NSLock()
+  private let lock = NSLock()
 
   /// Pending tasks that have not finished execution yet.
-  private var pendingTasks = [PendingTask]()
+  ///
+  /// - Important: This must only be accessed while `lock` has been acquired.
+  private var tasks: [PendingTask<TaskMetadata>] = []
 
-  public init() {
-    self.pendingTasksLock.name = "AsyncQueue"
+  init() {
+    self.lock.name = "AsyncQueue"
   }
 
+  /// Capture a lock and execute the closure, which may modify the pending tasks.
+  func withLock<T>(_ body: (_ pendingTasks: inout [PendingTask<TaskMetadata>]) throws -> T) rethrows -> T {
+    try lock.withLock {
+      try body(&tasks)
+    }
+  }
+}
+
+/// A queue that allows the execution of asynchronous blocks of code.
+public final class AsyncQueue<TaskMetadata: DependencyTracker> {
+  private var pendingTasks: PendingTasks<TaskMetadata> = PendingTasks()
+
+  public init() {}
+
   /// Schedule a new closure to be executed on the queue.
   ///
   /// If this is a serial queue, all previously added tasks are guaranteed to
@@ -108,13 +126,13 @@ public final class AsyncQueue<TaskMetadata: DependencyTracker> {
   ) -> Task<Success, any Error> {
     let id = UUID()
 
-    return pendingTasksLock.withLock {
+    return pendingTasks.withLock { tasks in
       // Build the list of tasks that need to finished execution before this one
       // can be executed
-      let dependencies: [PendingTask] = pendingTasks.filter { $0.metadata.isDependency(of: metadata) }
+      let dependencies: [PendingTask] = tasks.filter { $0.metadata.isDependency(of: metadata) }
 
       // Schedule the task.
-      let task = Task {
+      let task = Task { [pendingTasks] in
         // IMPORTANT: The only throwing call in here must be the call to
         // operation. Otherwise the assumption that the task will never throw
         // if `operation` does not throw, which we are making in `async` does
@@ -125,14 +143,14 @@ public final class AsyncQueue<TaskMetadata: DependencyTracker> {
 
         let result = try await operation()
 
-        pendingTasksLock.withLock {
-          pendingTasks.removeAll(where: { $0.id == id })
+        pendingTasks.withLock { tasks in
+          tasks.removeAll(where: { $0.id == id })
         }
 
         return result
       }
 
-      pendingTasks.append(PendingTask(task: task, metadata: metadata, id: id))
+      tasks.append(PendingTask(task: task, metadata: metadata, id: id))
 
       return task
     }

Sources/SKSupport/AsyncUtils.swift

@@ -15,7 +15,7 @@ import Foundation
 /// Wrapper around a task that allows multiple clients to depend on the task's value.
 ///
 /// If all of the dependents are cancelled, the underlying task is cancelled as well.
-public actor RefCountedCancellableTask<Success> {
+public actor RefCountedCancellableTask<Success: Sendable> {
   public let task: Task<Success, Error>
 
   /// The number of clients that depend on the task's result and that are not cancelled.
@@ -85,7 +85,7 @@ public extension Task {
 /// cancelled, `cancel` is invoked with the handle that `operation` provided.
 public func withCancellableCheckedThrowingContinuation<Handle, Result>(
   _ operation: (_ continuation: CheckedContinuation<Result, any Error>) -> Handle,
-  cancel: (Handle) -> Void
+  cancel: @Sendable (Handle) -> Void
 ) async throws -> Result {
   let handleWrapper = ThreadSafeBox<Handle?>(initialValue: nil)
 
@@ -117,11 +117,11 @@ public func withCancellableCheckedThrowingContinuation<Handle, Result>(
   )
 }
 
-extension Collection {
+extension Collection where Element: Sendable {
   /// Transforms all elements in the collection concurrently and returns the transformed collection.
-  public func concurrentMap<TransformedElement>(
+  public func concurrentMap<TransformedElement: Sendable>(
     maxConcurrentTasks: Int = ProcessInfo.processInfo.processorCount,
-    _ transform: @escaping (Element) async -> TransformedElement
+    _ transform: @escaping @Sendable (Element) async -> TransformedElement
   ) async -> [TransformedElement] {
     let indexedResults = await withTaskGroup(of: (index: Int, element: TransformedElement).self) { taskGroup in
       var indexedResults: [(index: Int, element: TransformedElement)] = []

Sources/SKSupport/ThreadSafeBox.swift

@@ -22,7 +22,9 @@ extension NSLock {
 }
 
 /// A thread safe container that contains a value of type `T`.
-public class ThreadSafeBox<T> {
+///
+/// - Note: Unchecked sendable conformance because value is guarded by a lock.
+public class ThreadSafeBox<T>: @unchecked Sendable {
   /// Lock guarding `_value`.
   private let lock = NSLock()
 

Sources/SKSupport/dlopen.swift

@@ -57,7 +57,7 @@ public final class DLHandle {
   }
 }
 
-public struct DLOpenFlags: RawRepresentable, OptionSet {
+public struct DLOpenFlags: RawRepresentable, OptionSet, Sendable {
 
   #if !os(Windows)
   public static let lazy: DLOpenFlags = DLOpenFlags(rawValue: RTLD_LAZY)