Revert "fix threading issue with symlink resolution"

This reverts commit 698e4bd.

# Conflicts:
#	Sources/TSCBasic/FileSystem.swift

Author: tgymnich

Sources/TSCBasic/FileSystem.swift

@@ -553,8 +553,19 @@ public class InMemoryFileSystem: FileSystem {
     /// tests.
     private let lock = Lock()
 
-    /// Exclusive file system lock vended to clients through `withLock()`.
+    private var lockFiles = Dictionary<AbsolutePath, WeakReference<DispatchQueue>>()
+    /// Used to access lockFiles in a thread safe manner.
     private let lockFilesLock = Lock()
+    
+    /// Exclusive file system lock vended to clients through `withLock()`.
+    // Used to ensure that DispatchQueues are releassed when they are no longer in use.
+    private struct WeakReference<Value: AnyObject> {
+        weak var reference: Value?
+
+        init(_ value: Value?) {
+            self.reference = value
+        }
+    }
 
     public init() {
         root = Node(.directory(DirectoryContents()))
@@ -895,8 +906,27 @@ public class InMemoryFileSystem: FileSystem {
     }
 
     public func withLock<T>(on path: AbsolutePath, type: FileLock.LockType = .exclusive, _ body: () throws -> T) throws -> T {
-        // FIXME: Lock individual files once resolving symlinks is thread-safe.
-        return try lockFilesLock.withLock(body)
+        let fileQueue: DispatchQueue = try lockFilesLock.withLock {
+
+            let resolvedPath: AbsolutePath
+
+            // FIXME: resolving symlinks is not yet thread safe
+            if case let .symlink(destination) = try getNode(path)?.contents {
+                resolvedPath = AbsolutePath(destination, relativeTo: path.parentDirectory)
+            } else {
+                resolvedPath = path
+            }
+
+            if let queueReference = lockFiles[resolvedPath], let queue = queueReference.reference {
+                return queue
+            } else {
+                let queue = DispatchQueue(label: "org.swift.swiftpm.in-memory-file-system.file-queue", attributes: .concurrent)
+                lockFiles[resolvedPath] = WeakReference(queue)
+                return queue
+            }
+        }
+
+        return try fileQueue.sync(flags: type == .exclusive ? .barrier : .init() , execute: body)
     }
 }