added property wrapper @ThreadLocal

Author: tgymnich

Sources/TSCBasic/Lock.swift

@@ -80,9 +80,9 @@ enum ProcessLockError: Swift.Error {
 public final class FileLock {
     /// File descriptor to the lock file.
   #if os(Windows)
-    private var handle: HANDLE?
+  @ThreadLocal @AutoClosing private var handle: HANDLE?
   #else
-    private var fileDescriptor: CInt?
+  @ThreadLocal @AutoClosing private var fileDescriptor: CInt?
   #endif
 
     /// Path to the lock file.
@@ -179,21 +179,11 @@ public final class FileLock {
         overlapped.hEvent = nil
         UnlockFileEx(handle, 0, DWORD(INT_MAX), DWORD(INT_MAX), &overlapped)
       #else
-        guard let fd = fileDescriptor else { return }
+      guard let fd = fileDescriptor else { return }
         flock(fd, LOCK_UN)
       #endif
     }
 
-    deinit {
-      #if os(Windows)
-        guard let handle = handle else { return }
-        CloseHandle(handle)
-      #else
-        guard let fd = fileDescriptor else { return }
-        close(fd)
-      #endif
-    }
-
     /// Execute the given block while holding the lock.
     public func withLock<T>(type: LockType = .exclusive, _ body: () throws -> T) throws -> T {
         try lock(type: type)

Sources/TSCBasic/Thread.swift

@@ -9,6 +9,7 @@
 */
 
 import Foundation
+import TSCLibc
 
 /// This class bridges the gap between Darwin and Linux Foundation Threading API.
 /// It provides closure based execution and a join method to block the calling thread
@@ -94,3 +95,60 @@ final private class ThreadImpl: Foundation.Thread {
 // Thread on Linux supports closure so just use it directly.
 typealias ThreadImpl = Foundation.Thread
 #endif
+
+protocol Defaultable {
+    static var defaultValue: Self { get }
+}
+
+extension Optional: Defaultable {
+    static var defaultValue: Optional<Wrapped> { .none }
+}
+
+/// `ThreadLocal` properties are  thread-specific. Every thread has its own instance of the wrapped property.
+@propertyWrapper final class ThreadLocal<Value: Defaultable> {
+    private var storage: NSMutableDictionary { ThreadImpl.current.threadDictionary }
+    private let key = UUID().uuidString
+
+    var wrappedValue: Value {
+        get {
+            if let value = storage[key] as? Value {
+                return value
+            } else {
+                let value = Value.defaultValue
+                storage[key] = value
+                return value
+            }
+        }
+        set { storage[key] = newValue }
+    }
+
+    init(wrappedValue: Value) {
+        self.wrappedValue = wrappedValue
+    }
+}
+
+/// Automatically closes the wrapped file descriptor on deinit.
+@propertyWrapper final class AutoClosing: NSObject, Defaultable {
+    #if os(Windows)
+    typealias T = HANDLE
+    #else
+    typealias T = CInt
+    #endif
+    var wrappedValue: T?
+
+    static var defaultValue: AutoClosing { AutoClosing(wrappedValue: .none) }
+
+    init(wrappedValue: T?) {
+        self.wrappedValue = wrappedValue
+    }
+
+    deinit {
+        if let wrappedValue = wrappedValue {
+            #if os(Windows)
+              CloseHandle(wrappedValue)
+            #else
+              close(wrappedValue)
+            #endif
+        }
+    }
+}

Tests/TSCBasicTests/LockTests.swift

@@ -90,7 +90,6 @@ class LockTests: XCTestCase {
 
             let writerThreads = (0..<100).map { _ in
                 return Thread {
-                    let lock = FileLock(name: "foo", cachePath: tempDir)
                     try! lock.withLock(type: .exclusive) {
                         // Get thr current contents of the file if any.
                         let valueA: Int
@@ -119,13 +118,12 @@ class LockTests: XCTestCase {
 
             let readerThreads = (0..<20).map { _ in
                 return Thread {
-                    let lock = FileLock(name: "foo", cachePath: tempDir)
                     try! lock.withLock(type: .shared) {
-                        try XCTAssertEqual( localFileSystem.readFileContents(fileA), localFileSystem.readFileContents(fileB))
+                        try XCTAssertEqual(localFileSystem.readFileContents(fileA), localFileSystem.readFileContents(fileB))
 
                         Thread.yield()
 
-                        try XCTAssertEqual( localFileSystem.readFileContents(fileA), localFileSystem.readFileContents(fileB))
+                        try XCTAssertEqual(localFileSystem.readFileContents(fileA), localFileSystem.readFileContents(fileB))
                     }
                 }
             }