Uses Native swift Atomics

Replaces the usage of CAtomics with the native
Atomics from the swift library and bumps the development platform
to macOS 15

Author: mustiikhalil

Package.swift

@@ -694,7 +694,7 @@ if buildOnlyTests {
 
 let package = Package(
   name: "SourceKitLSP",
-  platforms: [.macOS(.v13)],
+  platforms: [.macOS("15")],
   products: products,
   dependencies: dependencies,
   targets: targets,

Sources/SwiftExtensions/Atomics.swift

@@ -10,97 +10,80 @@
 //
 //===----------------------------------------------------------------------===//
 
-import CAtomics
+import Synchronization
 
-// TODO: Use atomic types from the standard library (https://github.com/swiftlang/sourcekit-lsp/issues/1949)
 package final class AtomicBool: Sendable {
-  private nonisolated(unsafe) let atomic: UnsafeMutablePointer<CAtomicUInt32>
+  private let atomic: Atomic<Bool>
 
   package init(initialValue: Bool) {
-    self.atomic = atomic_uint32_create(initialValue ? 1 : 0)
-  }
-
-  deinit {
-    atomic_uint32_destroy(atomic)
+    self.atomic = Atomic(initialValue)
   }
 
   package var value: Bool {
     get {
-      atomic_uint32_get(atomic) != 0
+      atomic.load(ordering: .sequentiallyConsistent)
     }
     set {
-      atomic_uint32_set(atomic, newValue ? 1 : 0)
+      atomic.store(newValue, ordering: .sequentiallyConsistent)
     }
   }
 }
 
 package final class AtomicUInt8: Sendable {
-  private nonisolated(unsafe) let atomic: UnsafeMutablePointer<CAtomicUInt32>
+  private let atomic: Atomic<UInt8>
 
   package init(initialValue: UInt8) {
-    self.atomic = atomic_uint32_create(UInt32(initialValue))
-  }
-
-  deinit {
-    atomic_uint32_destroy(atomic)
+    self.atomic = Atomic(initialValue)
   }
 
   package var value: UInt8 {
     get {
-      UInt8(atomic_uint32_get(atomic))
+      atomic.load(ordering: .sequentiallyConsistent)
     }
     set {
-      atomic_uint32_set(atomic, UInt32(newValue))
+      atomic.store(newValue, ordering: .sequentiallyConsistent)
     }
   }
 }
 
 package final class AtomicUInt32: Sendable {
-  private nonisolated(unsafe) let atomic: UnsafeMutablePointer<CAtomicUInt32>
+  private let atomic: Atomic<UInt32>
 
   package init(initialValue: UInt32) {
-    self.atomic = atomic_uint32_create(initialValue)
+    self.atomic = Atomic(initialValue)
   }
 
   package var value: UInt32 {
     get {
-      atomic_uint32_get(atomic)
+      atomic.load(ordering: .sequentiallyConsistent)
     }
     set {
-      atomic_uint32_set(atomic, newValue)
+      atomic.store(newValue, ordering: .sequentiallyConsistent)
     }
   }
 
-  deinit {
-    atomic_uint32_destroy(atomic)
-  }
-
   package func fetchAndIncrement() -> UInt32 {
-    return atomic_uint32_fetch_and_increment(atomic)
+    atomic.add(1, ordering: .sequentiallyConsistent).oldValue
   }
 }
 
 package final class AtomicInt32: Sendable {
-  private nonisolated(unsafe) let atomic: UnsafeMutablePointer<CAtomicInt32>
+  private let atomic: Atomic<Int32>
 
   package init(initialValue: Int32) {
-    self.atomic = atomic_int32_create(initialValue)
+    self.atomic = Atomic(initialValue)
   }
 
   package var value: Int32 {
     get {
-      atomic_int32_get(atomic)
+      atomic.load(ordering: .sequentiallyConsistent)
     }
     set {
-      atomic_int32_set(atomic, newValue)
+      atomic.store(newValue, ordering: .sequentiallyConsistent)
     }
   }
 
-  deinit {
-    atomic_int32_destroy(atomic)
-  }
-
   package func fetchAndIncrement() -> Int32 {
-    return atomic_int32_fetch_and_increment(atomic)
+    atomic.add(1, ordering: .sequentiallyConsistent).oldValue
   }
 }