Update for Swift 6 with thread safety improvements (#20)

* Update to Swift 6 and improve thread safety

* Update to Swift 6

* Update ExampleTests.swift

* Update to fix tests

* Add concurrency stress tests (#21)

* Add thread safety tests

* Update ThreadSafetyTests.swift

* Update ThreadSafetyTests.swift

* Update ThreadSafetyTests.swift

Author: 0xLeif

.github/workflows/macOS.yml

@@ -2,15 +2,15 @@ name: macOS
 
 on:
   push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
+    branches: ["**"]
 
 jobs:
   build:
     runs-on: macos-latest
-
     steps:
+    - uses: maxim-lobanov/setup-xcode@v1
+      with:
+        xcode-version: 16.0
     - uses: actions/checkout@v3
     - name: Build
       run: swift build -v

.github/workflows/ubuntu.yml

@@ -2,17 +2,18 @@ name: Ubuntu
 
 on:
   push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
+    branches: ["**"]
 
 jobs:
   build:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Build
-      run: swift build -v
-    - name: Run tests
-      run: swift test -v
+      - uses: sersoft-gmbh/swifty-linux-action@v3
+        with:
+          release-version: 6.0.1
+      - uses: actions/checkout@v3
+      - name: Build for release
+        run: swift build -v -c release
+      - name: Test
+        run: swift test -v

.github/workflows/windows.yml

@@ -2,19 +2,22 @@ name: Windows
 
 on:
   push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
+    branches: ["**"]
 
 jobs:
   build:
     runs-on: windows-latest
     steps:
-      - uses: compnerd/gha-setup-swift@main
+      - uses: actions/checkout@v4
+
+      # ① Install Swift for Windows
+      - name: Set up Swift 6.1
+        uses: compnerd/gha-setup-swift@main
         with:
-          branch: swift-5.8-release
-          tag: 5.8-RELEASE
-  
-      - uses: actions/checkout@v2
+          branch: swift-6.1-release   # release branch
+          tag:    6.1-RELEASE         # exact toolchain tag
+
+      # ② Build & test
+      - run: swift --version          # sanity-check
       - run: swift build
-      - run: swift test
+      - run: swift test

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.6
+// swift-tools-version: 6.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription

README.md

@@ -2,6 +2,8 @@
 
 *A simple, lightweight caching library for Swift.*
 
+Requires **Swift 6.0** or later.
+
 ## What is Cache?
 
 Cache is a Swift library for caching arbitrary data types in memory. It provides a simple and intuitive API for storing, retrieving, and removing objects from the cache.

Sources/Cache/Cache/AnyCacheable.swift

@@ -1,8 +1,10 @@
 #if !os(Windows)
-public class AnyCacheable: Cacheable {
+import Foundation
+public class AnyCacheable: Cacheable, @unchecked Sendable {
     public typealias Key = AnyHashable
     public typealias Value = Any
 
+    private let lock = NSRecursiveLock()
     private var cache: any Cacheable
 
     private var cacheGet: ((AnyHashable) -> Any?)!
@@ -93,6 +95,7 @@ public class AnyCacheable: Cacheable {
         _ key: AnyHashable,
         as: Output.Type = Output.self
     ) -> Output? {
+        lock.lock(); defer { lock.unlock() }
         guard let value = cacheGet(key) else {
             return nil
         }
@@ -108,6 +111,7 @@ public class AnyCacheable: Cacheable {
         _ key: AnyHashable,
         as: Output.Type = Output.self
     ) throws -> Output {
+        lock.lock(); defer { lock.unlock() }
         let resolvedValue = try cacheResolve(key)
 
         guard let output = resolvedValue as? Output else {
@@ -121,31 +125,37 @@ public class AnyCacheable: Cacheable {
     }
 
     public func set(value: Value, forKey key: AnyHashable) {
+        lock.lock(); defer { lock.unlock() }
         cacheSet(value, key)
     }
 
     public func remove(_ key: AnyHashable) {
+        lock.lock(); defer { lock.unlock() }
         cacheRemove(key)
     }
 
     public func contains(_ key: AnyHashable) -> Bool {
-        cacheContains(key)
+        lock.lock(); defer { lock.unlock() }
+        return cacheContains(key)
     }
 
     public func require(keys: Set<AnyHashable>) throws -> Self {
+        lock.lock(); defer { lock.unlock() }
         try cacheRequireKeys(keys)
 
         return self
     }
 
     public func require(_ key: AnyHashable) throws -> Self {
+        lock.lock(); defer { lock.unlock() }
         try cacheRequireKey(key)
 
         return self
     }
 
     public func values<Output>(ofType: Output.Type) -> [AnyHashable: Output] {
-        cacheValues().compactMapValues { value in
+        lock.lock(); defer { lock.unlock() }
+        return cacheValues().compactMapValues { value in
             value as? Output
         }
     }

Sources/Cache/Cache/Cache.swift

@@ -13,7 +13,7 @@ import Foundation
  let age = cache.get("age") // age is now 100
  ```
  */
-open class Cache<Key: Hashable, Value>: Cacheable {
+open class Cache<Key: Hashable, Value>: Cacheable, @unchecked Sendable {
 
     /// Lock to synchronize the access to the cache dictionary.
     fileprivate var lock: NSLock

Sources/Cache/Cache/ComposableCache.swift

@@ -1,5 +1,7 @@
 #if !os(Windows)
-public struct ComposableCache<Key: Hashable>: Cacheable {
+import Foundation
+public struct ComposableCache<Key: Hashable>: Cacheable, @unchecked Sendable {
+    private let lock = NSRecursiveLock()
     private let caches: [AnyCacheable]
 
     public init(caches: [any Cacheable]) {
@@ -14,6 +16,7 @@ public struct ComposableCache<Key: Hashable>: Cacheable {
         _ key: Key,
         as: Output.Type = Output.self
     ) -> Output? {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             guard
                 let output = cache.get(key, as: Output.self)
@@ -31,6 +34,7 @@ public struct ComposableCache<Key: Hashable>: Cacheable {
         _ key: Key,
         as: Output.Type = Output.self
     ) throws -> Output {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             guard
                 let output = try? cache.resolve(key, as: Output.self)
@@ -45,18 +49,21 @@ public struct ComposableCache<Key: Hashable>: Cacheable {
     }
 
     public func set(value: Any, forKey key: Key) {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             cache.set(value: value, forKey: key)
         }
     }
 
     public func remove(_ key: Key) {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             cache.remove(key)
         }
     }
 
     public func contains(_ key: Key) -> Bool {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             if cache.contains(key) {
                 return true
@@ -67,6 +74,7 @@ public struct ComposableCache<Key: Hashable>: Cacheable {
     }
 
     public func require(keys: Set<Key>) throws -> ComposableCache<Key> {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             _ = try cache.require(keys: keys)
         }
@@ -75,6 +83,7 @@ public struct ComposableCache<Key: Hashable>: Cacheable {
     }
 
     public func require(_ key: Key) throws -> ComposableCache<Key> {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             _ = try cache.require(key)
         }
@@ -83,6 +92,7 @@ public struct ComposableCache<Key: Hashable>: Cacheable {
     }
 
     public func values<Output>(ofType: Output.Type) -> [Key: Output] {
+        lock.lock(); defer { lock.unlock() }
         for cache in caches {
             let values = cache.values(ofType: Output.self).compactMapKeys { $0 as? Key }
 

Sources/Cache/Cache/ExpiringCache.swift

@@ -9,9 +9,9 @@ import Foundation
 
  Objects stored in the cache are automatically removed when their expiration duration has passed.
  */
-public class ExpiringCache<Key: Hashable, Value>: Cacheable {
+public class ExpiringCache<Key: Hashable, Value>: Cacheable, @unchecked Sendable {
     /// `Error` that reports expired values
-    public struct ExpiriedValueError: LocalizedError {
+    public struct ExpiriedValueError: LocalizedError, @unchecked Sendable {
         /// Expired key
         public let key: Key
 
@@ -71,7 +71,7 @@ public class ExpiringCache<Key: Hashable, Value>: Cacheable {
         }
     }
 
-    private struct ExpiringValue {
+    private struct ExpiringValue: @unchecked Sendable {
         let expriation: Date
         let value: Value
     }

Sources/Cache/Cache/LRUCache.swift

@@ -11,7 +11,8 @@ Error Handling: The set(value:forKey:) function does not throw any error. Instea
 
 The `LRUCache` class is a subclass of the `Cache` class. You can use its `capacity` property to specify the maximum number of key-value pairs that the cache can hold.
 */
-public class LRUCache<Key: Hashable, Value>: Cache<Key, Value> {
+public class LRUCache<Key: Hashable, Value>: Cache<Key, Value>, @unchecked Sendable {
+    private let lock = NSRecursiveLock()
     private var keys: [Key]
 
     /// The maximum capacity of the cache.
@@ -46,6 +47,7 @@ public class LRUCache<Key: Hashable, Value>: Cache<Key, Value> {
     }
 
     public override func get<Output>(_ key: Key, as: Output.Type = Output.self) -> Output? {
+        lock.lock(); defer { lock.unlock() }
         guard let value = super.get(key, as: Output.self) else {
             return nil
         }
@@ -56,13 +58,15 @@ public class LRUCache<Key: Hashable, Value>: Cache<Key, Value> {
     }
 
     public override func set(value: Value, forKey key: Key) {
+        lock.lock(); defer { lock.unlock() }
         super.set(value: value, forKey: key)
 
         updateKeys(recentlyUsed: key)
         checkCapacity()
     }
 
     public override func remove(_ key: Key) {
+        lock.lock(); defer { lock.unlock() }
         super.remove(key)
 
         if let index = keys.firstIndex(of: key) {
@@ -71,6 +75,7 @@ public class LRUCache<Key: Hashable, Value>: Cache<Key, Value> {
     }
 
     public override func contains(_ key: Key) -> Bool {
+        lock.lock(); defer { lock.unlock() }
         guard super.contains(key) else {
             return false
         }