Introduced LockIsolated into the codebase

Author: lukaskubanek

Sources/InterposeKit/Hooks/HookStrategy/ObjectHookStrategy/ObjectSubclassManager.swift

@@ -136,9 +136,9 @@ internal enum ObjectSubclassManager {
     ) -> String {
         let className = NSStringFromClass(perceivedClass)
 
-        let counterSuffix: String = self.subclassCounterQueue.sync {
-            self.subclassCounter &+= 1
-            return String(format: "%04llx", self.subclassCounter)
+        let counterSuffix: String = self.subclassCounter.withValue { counter in
+            counter &+= 1
+            return String(format: "%04llx", counter)
         }
 
         return "\(self.namePrefix)_\(className)_\(counterSuffix)"
@@ -147,10 +147,7 @@ internal enum ObjectSubclassManager {
     /// The prefix used for all dynamically created subclass names.
     private static let namePrefix = "InterposeKit"
 
-    /// A global counter for generating unique subclass name suffixes.
-    private static var subclassCounter: UInt64 = 0
-    
-    /// A serial queue to ensure thread-safe access to `subclassCounter`.
-    private static let subclassCounterQueue = DispatchQueue(label: "com.steipete.InterposeKit.subclassCounter")
+    /// A lock-isolated global counter for generating unique subclass name suffixes.
+    private static let subclassCounter = LockIsolated<UInt64>(0)
 
 }

Sources/InterposeKit/Utilities/Concurrency/LockIsolated.swift

@@ -0,0 +1,41 @@
+// A modified version from Point-Free’s Concurrency Extras package:
+// https://github.com/pointfreeco/swift-concurrency-extras
+//
+// Copyright (c) 2023 Point-Free
+// Licensed under the MIT license.
+
+import Foundation
+
+internal final class LockIsolated<Value>: @unchecked Sendable {
+    private var _value: Value
+    private let lock = NSRecursiveLock()
+    
+    internal init(_ value: @autoclosure @Sendable () throws -> Value) rethrows {
+        self._value = try value()
+    }
+    
+    internal var value: Value {
+        self.lock.sync {
+            self._value
+        }
+    }
+    
+    internal func withValue<T: Sendable>(
+        _ operation: @Sendable (inout Value) throws -> T
+    ) rethrows -> T {
+        try self.lock.sync {
+            var value = self._value
+            defer { self._value = value }
+            return try operation(&value)
+        }
+    }
+}
+
+extension NSRecursiveLock {
+    @discardableResult
+    fileprivate func sync<R>(work: () throws -> R) rethrows -> R {
+        self.lock()
+        defer { self.unlock() }
+        return try work()
+    }
+}