Removes atomic wrappers infavor of using them directly

Replacing the usage of Int32, and UInt32 with Int since the previous was only used because of c bridging

Uses .sequentiallyConsistent for all loading and storing methods

Author: mustiikhalil

Diff for: Sources/BuildSystemIntegration/SwiftPMBuildSystem.swift

@@ -22,6 +22,7 @@ import SKLogging
 @preconcurrency package import SPMBuildCore
 import SourceControl
 import SwiftExtensions
+import Synchronization
 import TSCExtensions
 @preconcurrency import Workspace
 
@@ -88,7 +89,7 @@ fileprivate extension TSCBasic.AbsolutePath {
   }
 }
 
-fileprivate let preparationTaskID: AtomicUInt32 = AtomicUInt32(initialValue: 0)
+fileprivate let preparationTaskID: Atomic<Int> = Atomic(0)
 
 /// Swift Package Manager build system and workspace support.
 ///
@@ -613,7 +614,9 @@ package actor SwiftPMBuildSystem: BuiltInBuildSystem {
     }
     let start = ContinuousClock.now
 
-    let taskID: TaskId = TaskId(id: "preparation-\(preparationTaskID.fetchAndIncrement())")
+    let taskID: TaskId = TaskId(
+      id: "preparation-\(preparationTaskID.add(1, ordering: .sequentiallyConsistent).oldValue)"
+    )
     logMessageToIndexLog(
       taskID,
       """

Diff for: Sources/CompletionScoringTestSupport/TestExtensions.swift

@@ -12,6 +12,7 @@
 
 import Foundation
 import SwiftExtensions
+import Synchronization
 import XCTest
 
 #if compiler(>=6)
@@ -106,7 +107,7 @@ extension XCTestCase {
     UserDefaults.standard.string(forKey: "TestMeasurementLogPath")
   }()
 
-  static let printBeginingOfLog = AtomicBool(initialValue: true)
+  static let printBeginingOfLog: Atomic<Bool> = Atomic(true)
 
   private static func openPerformanceLog() throws -> FileHandle? {
     try measurementsLogFile.map { path in
@@ -119,9 +120,9 @@ extension XCTestCase {
       }
       let logFD = try FileHandle(forWritingAtPath: path).unwrap(orThrow: "Opening \(path) failed")
       try logFD.seekToEnd()
-      if printBeginingOfLog.value {
+      if printBeginingOfLog.load(ordering: .sequentiallyConsistent) {
         try logFD.print("========= \(Date().description(with: .current)) =========")
-        printBeginingOfLog.value = false
+        printBeginingOfLog.store(false, ordering: .sequentiallyConsistent)
       }
       return logFD
     }

Diff for: Sources/Diagnose/DiagnoseCommand.swift

@@ -34,6 +34,8 @@ import class TSCBasic.Process
 import class TSCUtility.PercentProgressAnimation
 #endif
 
+import Synchronization
+
 /// When diagnosis is started, a progress bar displayed on the terminal that shows how far the diagnose command has
 /// progressed.
 /// Can't be a member of `DiagnoseCommand` because then `DiagnoseCommand` is no longer codable, which it needs to be
@@ -233,8 +235,8 @@ package struct DiagnoseCommand: AsyncParsableCommand {
       throw GenericError("Failed to create log.txt")
     }
     let fileHandle = try FileHandle(forWritingTo: outputFileUrl)
-    let bytesCollected = AtomicInt32(initialValue: 0)
-    let processExited = AtomicBool(initialValue: false)
+    let bytesCollected: Atomic<Int> = Atomic(0)
+    let processExited: Atomic<Bool> = Atomic(false)
     // 50 MB is an average log size collected by sourcekit-lsp diagnose.
     // It's a good proxy to show some progress indication for the majority of the time.
     let expectedLogSize = 50_000_000
@@ -250,16 +252,16 @@ package struct DiagnoseCommand: AsyncParsableCommand {
       outputRedirection: .stream(
         stdout: { @Sendable bytes in
           try? fileHandle.write(contentsOf: bytes)
-          bytesCollected.value += Int32(bytes.count)
-          var progress = Double(bytesCollected.value) / Double(expectedLogSize)
+          let count = bytesCollected.add(bytes.count, ordering: .sequentiallyConsistent).newValue
+          var progress = Double(count) / Double(expectedLogSize)
           if progress > 1 {
             // The log is larger than we expected. Halt at 100%
             progress = 1
           }
           Task(priority: .high) {
             // We have launched an async task to call `reportProgress`, which means that the process might have exited
             // before we execute this task. To avoid overriding a more recent progress, add a guard.
-            if !processExited.value {
+            if !processExited.load(ordering: .sequentiallyConsistent) {
               await reportProgress(.collectingLogMessages(progress: progress), message: "Collecting log messages")
             }
           }
@@ -269,7 +271,7 @@ package struct DiagnoseCommand: AsyncParsableCommand {
     )
     try process.launch()
     try await process.waitUntilExit()
-    processExited.value = true
+    processExited.store(true, ordering: .sequentiallyConsistent)
     #endif
   }
 

Diff for: Sources/InProcessClient/InProcessSourceKitLSPClient.swift

@@ -28,11 +28,13 @@ import SKOptions
 import SourceKitLSP
 #endif
 
+import Synchronization
+
 /// Launches a `SourceKitLSPServer` in-process and allows sending messages to it.
 public final class InProcessSourceKitLSPClient: Sendable {
   private let server: SourceKitLSPServer
 
-  private let nextRequestID = AtomicUInt32(initialValue: 0)
+  private let nextRequestID: Atomic<Int> = Atomic(0)
 
   public convenience init(
     toolchainPath: URL?,
@@ -100,7 +102,11 @@ public final class InProcessSourceKitLSPClient: Sendable {
 
   /// Send the request to `server` and return the request result via a completion handler.
   public func send<R: RequestType>(_ request: R, reply: @Sendable @escaping (LSPResult<R.Response>) -> Void) {
-    server.handle(request, id: .number(Int(nextRequestID.fetchAndIncrement())), reply: reply)
+    server.handle(
+      request,
+      id: .number(Int(nextRequestID.add(1, ordering: .sequentiallyConsistent).oldValue)),
+      reply: reply
+    )
   }
 
   /// Send the notification to `server`.

Diff for: Sources/LanguageServerProtocolExtensions/QueueBasedMessageHandler.swift

@@ -13,6 +13,7 @@
 import Foundation
 import LanguageServerProtocolJSONRPC
 import SKLogging
+import Synchronization
 
 #if compiler(>=6)
 package import LanguageServerProtocol
@@ -41,7 +42,7 @@ package actor QueueBasedMessageHandlerHelper {
   private let cancellationMessageHandlingQueue = AsyncQueue<Serial>()
 
   /// Notifications don't have an ID. This represents the next ID we can use to identify a notification.
-  private let notificationIDForLogging = AtomicUInt32(initialValue: 1)
+  private let notificationIDForLogging: Atomic<Int> = Atomic(1)
 
   /// The requests that we are currently handling.
   ///
@@ -103,7 +104,7 @@ package actor QueueBasedMessageHandlerHelper {
     // Only use the last two digits of the notification ID for the logging scope to avoid creating too many scopes.
     // See comment in `withLoggingScope`.
     // The last 2 digits should be sufficient to differentiate between multiple concurrently running notifications.
-    let notificationID = notificationIDForLogging.fetchAndIncrement()
+    let notificationID = notificationIDForLogging.add(1, ordering: .sequentiallyConsistent).oldValue
     withLoggingScope("notification-\(notificationID % 100)") {
       body()
     }

Diff for: Sources/LanguageServerProtocolExtensions/RequestAndReply.swift

@@ -18,27 +18,29 @@ import LanguageServerProtocol
 import SwiftExtensions
 #endif
 
+import Synchronization
+
 /// A request and a callback that returns the request's reply
 package final class RequestAndReply<Params: RequestType>: Sendable {
   package let params: Params
   private let replyBlock: @Sendable (LSPResult<Params.Response>) -> Void
 
   /// Whether a reply has been made. Every request must reply exactly once.
-  private let replied: AtomicBool = AtomicBool(initialValue: false)
+  private let replied: Atomic<Bool> = Atomic(false)
 
   package init(_ request: Params, reply: @escaping @Sendable (LSPResult<Params.Response>) -> Void) {
     self.params = request
     self.replyBlock = reply
   }
 
   deinit {
-    precondition(replied.value, "request never received a reply")
+    precondition(replied.load(ordering: .sequentiallyConsistent), "request never received a reply")
   }
 
   /// Call the `replyBlock` with the result produced by the given closure.
   package func reply(_ body: @Sendable () async throws -> Params.Response) async {
-    precondition(!replied.value, "replied to request more than once")
-    replied.value = true
+    precondition(!replied.load(ordering: .sequentiallyConsistent), "replied to request more than once")
+    replied.store(true, ordering: .sequentiallyConsistent)
     do {
       replyBlock(.success(try await body()))
     } catch {

Diff for: Sources/SKLogging/NonDarwinLogging.swift

@@ -23,6 +23,8 @@ import Foundation
 @preconcurrency import Foundation
 #endif
 
+import Synchronization
+
 // MARK: - Log settings
 
 package enum LogConfig {
@@ -407,14 +409,14 @@ package struct NonDarwinLogger: Sendable {
 // MARK: - Signposter
 
 package struct NonDarwinSignpostID: Sendable {
-  fileprivate let id: UInt32
+  fileprivate let id: Int
 }
 
 package struct NonDarwinSignpostIntervalState: Sendable {
   fileprivate let id: NonDarwinSignpostID
 }
 
-private let nextSignpostID = AtomicUInt32(initialValue: 0)
+private let nextSignpostID: Atomic<Int> = Atomic(0)
 
 /// A type that is API-compatible to `OSLogMessage` for all uses within sourcekit-lsp.
 ///
@@ -427,7 +429,7 @@ package struct NonDarwinSignposter: Sendable {
   }
 
   package func makeSignpostID() -> NonDarwinSignpostID {
-    return NonDarwinSignpostID(id: nextSignpostID.fetchAndIncrement())
+    return NonDarwinSignpostID(id: nextSignpostID.add(1, ordering: .sequentiallyConsistent).oldValue)
   }
 
   package func beginInterval(

Diff for: Sources/SKTestSupport/TestSourceKitLSPClient.swift

@@ -18,6 +18,7 @@ import SKUtilities
 import SourceKitD
 import SwiftExtensions
 import SwiftSyntax
+import Synchronization
 import XCTest
 
 #if compiler(>=6)
@@ -87,7 +88,7 @@ package final class TestSourceKitLSPClient: MessageHandler, Sendable {
   package typealias RequestHandler<Request: RequestType> = @Sendable (Request) -> Request.Response
 
   /// The ID that should be assigned to the next request sent to the `server`.
-  private let nextRequestID = AtomicUInt32(initialValue: 0)
+  private let nextRequestID: Atomic<Int> = Atomic(0)
 
   /// The server that handles the requests.
   package let server: SourceKitLSPServer
@@ -216,7 +217,7 @@ package final class TestSourceKitLSPClient: MessageHandler, Sendable {
     // It's really unfortunate that there are no async deinits. If we had async
     // deinits, we could await the sending of a ShutdownRequest.
     let sema = DispatchSemaphore(value: 0)
-    server.handle(ShutdownRequest(), id: .number(Int(nextRequestID.fetchAndIncrement()))) { result in
+    server.handle(ShutdownRequest(), id: .number(Int(nextRequestID.add(1, ordering: .sequentiallyConsistent).oldValue))) { result in
       sema.signal()
     }
     sema.wait()
@@ -251,7 +252,7 @@ package final class TestSourceKitLSPClient: MessageHandler, Sendable {
     _ request: R,
     completionHandler: @Sendable @escaping (LSPResult<R.Response>) -> Void
   ) -> RequestID {
-    let requestID = RequestID.number(Int(nextRequestID.fetchAndIncrement()))
+    let requestID = RequestID.number(Int(nextRequestID.add(1, ordering: .sequentiallyConsistent).oldValue))
     server.handle(request, id: requestID) { result in
       completionHandler(result)
     }

Diff for: Sources/SemanticIndex/IndexTaskDescription.swift

@@ -20,7 +20,7 @@ protocol IndexTaskDescription: TaskDescriptionProtocol {
   /// different types in `AnyIndexTaskDescription`
   static var idPrefix: String { get }
 
-  var id: UInt32 { get }
+  var id: Int { get }
 }
 
 extension IndexTaskDescription {

Diff for: Sources/SemanticIndex/PreparationTaskDescription.swift

@@ -34,15 +34,17 @@ import struct TSCBasic.AbsolutePath
 import class TSCBasic.Process
 #endif
 
-private let preparationIDForLogging = AtomicUInt32(initialValue: 1)
+import Synchronization
+
+private let preparationIDForLogging: Atomic<Int> = Atomic(1)
 
 /// Describes a task to prepare a set of targets.
 ///
 /// This task description can be scheduled in a `TaskScheduler`.
 package struct PreparationTaskDescription: IndexTaskDescription {
   package static let idPrefix = "prepare"
 
-  package let id = preparationIDForLogging.fetchAndIncrement()
+  package let id = preparationIDForLogging.add(1, ordering: .sequentiallyConsistent).oldValue
 
   /// The targets that should be prepared.
   package let targetsToPrepare: [BuildTargetIdentifier]

Diff for: Sources/SemanticIndex/TaskScheduler.swift

@@ -22,6 +22,8 @@ import SKLogging
 import SwiftExtensions
 #endif
 
+import Synchronization
+
 /// See comment on ``TaskDescriptionProtocol/dependencies(to:taskPriority:)``
 package enum TaskDependencyAction<TaskDescription: TaskDescriptionProtocol> {
   case waitAndElevatePriorityOfDependency(TaskDescription)
@@ -133,18 +135,18 @@ package actor QueuedTask<TaskDescription: TaskDescriptionProtocol> {
   /// Every time `execute` gets called, a new task is placed in this continuation. See comment on `executionTask`.
   private let executionTaskCreatedContinuation: AsyncStream<Task<ExecutionTaskFinishStatus, Never>>.Continuation
 
-  private let _priority: AtomicUInt8
+  private let _priority: Atomic<UInt8>
 
   /// The latest known priority of the task.
   ///
   /// This starts off as the priority with which the task is being created. If higher priority tasks start depending on
   /// it, the priority may get elevated.
   nonisolated var priority: TaskPriority {
     get {
-      TaskPriority(rawValue: _priority.value)
+      TaskPriority(rawValue: _priority.load(ordering: .sequentiallyConsistent))
     }
     set {
-      _priority.value = newValue.rawValue
+      _priority.store(newValue.rawValue, ordering: .sequentiallyConsistent)
     }
   }
 
@@ -154,13 +156,13 @@ package actor QueuedTask<TaskDescription: TaskDescriptionProtocol> {
   private var cancelledToBeRescheduled: Bool = false
 
   /// Whether `resultTask` has been cancelled.
-  private let resultTaskCancelled: AtomicBool = .init(initialValue: false)
+  private let resultTaskCancelled: Atomic<Bool> = Atomic(false)
 
-  private let _isExecuting: AtomicBool = .init(initialValue: false)
+  private let _isExecuting: Atomic<Bool> = Atomic(false)
 
   /// Whether the task is currently executing or still queued to be executed later.
   package nonisolated var isExecuting: Bool {
-    return _isExecuting.value
+    return _isExecuting.load(ordering: .sequentiallyConsistent)
   }
 
   package nonisolated func cancel() {
@@ -193,7 +195,7 @@ package actor QueuedTask<TaskDescription: TaskDescriptionProtocol> {
     description: TaskDescription,
     executionStateChangedCallback: (@Sendable (QueuedTask, TaskExecutionState) async -> Void)?
   ) async {
-    self._priority = AtomicUInt8(initialValue: priority.rawValue)
+    self._priority = Atomic<UInt8>(priority.rawValue)
     self.description = description
     self.executionStateChangedCallback = executionStateChangedCallback
 
@@ -225,7 +227,7 @@ package actor QueuedTask<TaskDescription: TaskDescriptionProtocol> {
           self.priority = Task.currentPriority
         }
       } onCancel: {
-        self.resultTaskCancelled.value = true
+        self.resultTaskCancelled.store(true, ordering: .sequentiallyConsistent)
       }
     }
   }
@@ -246,12 +248,12 @@ package actor QueuedTask<TaskDescription: TaskDescriptionProtocol> {
     }
     precondition(executionTask == nil, "Task started twice")
     let task = Task.detached(priority: self.priority) {
-      if !Task.isCancelled && !self.resultTaskCancelled.value {
+      if !Task.isCancelled && !self.resultTaskCancelled.load(ordering: .sequentiallyConsistent) {
         await self.description.execute()
       }
       return await self.finalizeExecution()
     }
-    _isExecuting.value = true
+    _isExecuting.store(true, ordering: .sequentiallyConsistent)
     executionTask = task
     executionTaskCreatedContinuation.yield(task)
     await executionStateChangedCallback?(self, .executing)
@@ -261,7 +263,7 @@ package actor QueuedTask<TaskDescription: TaskDescriptionProtocol> {
   /// Implementation detail of `execute` that is called after `self.description.execute()` finishes.
   private func finalizeExecution() async -> ExecutionTaskFinishStatus {
     self.executionTask = nil
-    _isExecuting.value = false
+    _isExecuting.store(false, ordering: .sequentiallyConsistent)
     if Task.isCancelled && self.cancelledToBeRescheduled {
       await executionStateChangedCallback?(self, .cancelledToBeRescheduled)
       self.cancelledToBeRescheduled = false