Convert ManifestLoader.evaluateManifest to async

Sources/Basics/Concurrency/ThreadSafeBox.swift

@@ -31,6 +31,8 @@ public final class ThreadSafeBox<Value> {
         }
     }
 
+    /// Modifies value stored in the box in-place, potentially avoiding copies.
+    /// - Parameter body: function applied to the stored value that modifies it.
     public func mutate(body: (inout Value?) throws -> ()) rethrows {
         try self.lock.withLock {
             try body(&self.underlying)

Sources/Basics/FileSystem/FileSystem+Extensions.swift

@@ -196,10 +196,25 @@ extension FileSystem {
     }
 
     /// Execute the given block while holding the lock.
-    public func withLock<T>(on path: AbsolutePath, type: FileLock.LockType, blocking: Bool = true, _ body: () throws -> T) throws -> T {
+    public func withLock<T>(
+        on path: AbsolutePath,
+        type: FileLock.LockType,
+        blocking: Bool = true,
+        _ body: () throws -> T
+    ) throws -> T {
         try self.withLock(on: path.underlying, type: type, blocking: blocking, body)
     }
 
+    /// Execute the given block while holding the lock.
+    public func withLock<T>(
+        on path: AbsolutePath,
+        type: FileLock.LockType,
+        blocking: Bool = true,
+        _ body: () async throws -> T
+    ) async throws -> T {
+        try await self.withLock(on: path.underlying, type: type, blocking: blocking, body)
+    }
+
     /// Returns any known item replacement directories for a given path. These may be used by platform-specific
     /// libraries to handle atomic file system operations, such as deletion.
     func itemReplacementDirectories(for path: AbsolutePath) throws -> [AbsolutePath] {

Sources/Basics/FileSystem/InMemoryFileSystem.swift

@@ -8,8 +8,8 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
  */
 
-import class Foundation.NSLock
 import class Dispatch.DispatchQueue
+import class Foundation.NSLock
 import struct TSCBasic.AbsolutePath
 import struct TSCBasic.ByteString
 import class TSCBasic.FileLock
@@ -23,7 +23,7 @@ public final class InMemoryFileSystem: FileSystem {
     private class Node {
         /// The actual node data.
         let contents: NodeContents
-        
+
         /// Whether the node has executable bit enabled.
         var isExecutable: Bool
 
@@ -86,10 +86,12 @@ public final class InMemoryFileSystem: FileSystem {
     /// tests.
     private let lock = NSLock()
     /// A map that keeps weak references to all locked files.
-    private var lockFiles = Dictionary<TSCBasic.AbsolutePath, WeakReference<DispatchQueue>>()
+    private var lockFiles = [TSCBasic.AbsolutePath: WeakReference<DispatchQueue>]()
     /// Used to access lockFiles in a thread safe manner.
     private let lockFilesLock = NSLock()
 
+    private let asyncFilesLock = [TSCBasic.AbsolutePath: NSLock]()
+
     /// Exclusive file system lock vended to clients through `withLock()`.
     /// Used to ensure that DispatchQueues are released when they are no longer in use.
     private struct WeakReference<Value: AnyObject> {
@@ -488,10 +490,40 @@ public final class InMemoryFileSystem: FileSystem {
             }
         }
 
-        return try fileQueue.sync(flags: type == .exclusive ? .barrier : .init() , execute: body)
+        return try fileQueue.sync(flags: type == .exclusive ? .barrier : .init(), execute: body)
     }
-
-    public func withLock<T>(on path: TSCBasic.AbsolutePath, type: FileLock.LockType, blocking: Bool, _ body: () throws -> T) throws -> T {
+
+    @available(*, deprecated, message: "Use of this overload can lead to deadlocks, use `AsyncFileSystem` instead.")
+    public func withLock<T>(
+        on path: TSCBasic.AbsolutePath,
+        type: FileLock.LockType = .exclusive,
+        blocking: Bool,
+        _ body: () async throws -> T
+    ) async throws -> T {
+        let resolvedPath: TSCBasic.AbsolutePath = try lock.withLock {
+            if case let .symlink(destination) = try getNode(path)?.contents {
+                return try .init(validating: destination, relativeTo: path.parentDirectory)
+            } else {
+                return path
+            }
+        }
+
+        // FIXME: code calling this function should be migrated to `AsyncFileSystem` instead.
+        self.asyncFilesLock[resolvedPath, default: NSLock()].lock()
+
+        let result = try await body()
+
+        self.asyncFilesLock[resolvedPath, default: NSLock()].unlock()
+
+        return result
+    }
+
+    public func withLock<T>(
+        on path: TSCBasic.AbsolutePath,
+        type: FileLock.LockType,
+        blocking: Bool,
+        _ body: () throws -> T
+    ) throws -> T {
         try self.withLock(on: path, type: type, body)
     }
 }

Sources/Basics/HTTPClient/HTTPClientConfiguration.swift

@@ -14,8 +14,7 @@ import Foundation
 
 public struct HTTPClientConfiguration: Sendable {
     // FIXME: this should be unified with ``AuthorizationProvider`` protocol or renamed to avoid unintended shadowing.
-    public typealias AuthorizationProvider = @Sendable (URL)
-        -> String?
+    public typealias AuthorizationProvider = @Sendable (URL) -> String?
 
     public init(
         requestHeaders: HTTPClientHeaders? = nil,

Sources/Commands/CommandWorkspaceDelegate.swift

@@ -184,30 +184,42 @@ final class CommandWorkspaceDelegate: WorkspaceDelegate {
 
     // registry signature handlers
 
-    func onUnsignedRegistryPackage(registryURL: URL, package: PackageModel.PackageIdentity, version: TSCUtility.Version, completion: (Bool) -> Void) {
-        self.inputHandler("\(package) \(version) from \(registryURL) is unsigned. okay to proceed? (yes/no) ") { response in
-            switch response?.lowercased() {
-            case "yes":
-                completion(true) // continue
-            case "no":
-                completion(false) // stop resolution
-            default:
-                self.outputHandler("invalid response: '\(response ?? "")'", false)
-                completion(false)
+    func onUnsignedRegistryPackage(
+        registryURL: URL,
+        package: PackageModel.PackageIdentity,
+        version: TSCUtility.Version
+    ) async -> Bool {
+        await withCheckedContinuation { continuation in
+            self.inputHandler("\(package) \(version) from \(registryURL) is unsigned. okay to proceed? (yes/no) ") { response in
+                switch response?.lowercased() {
+                case "yes":
+                    continuation.resume(returning: true) // continue
+                case "no":
+                    continuation.resume(returning: false) // stop resolution
+                default:
+                    self.outputHandler("invalid response: '\(response ?? "")'", false)
+                    continuation.resume(returning: false)
+                }
             }
         }
     }
 
-    func onUntrustedRegistryPackage(registryURL: URL, package: PackageModel.PackageIdentity, version: TSCUtility.Version, completion: (Bool) -> Void) {
-        self.inputHandler("\(package) \(version) from \(registryURL) is signed with an untrusted certificate. okay to proceed? (yes/no) ") { response in
-            switch response?.lowercased() {
-            case "yes":
-                completion(true) // continue
-            case "no":
-                completion(false) // stop resolution
-            default:
-                self.outputHandler("invalid response: '\(response ?? "")'", false)
-                completion(false)
+    func onUntrustedRegistryPackage(
+        registryURL: URL,
+        package: PackageModel.PackageIdentity,
+        version: TSCUtility.Version
+    ) async -> Bool {
+        await withCheckedContinuation { continuation in
+            self.inputHandler("\(package) \(version) from \(registryURL) is signed with an untrusted certificate. okay to proceed? (yes/no) ") { response in
+                switch response?.lowercased() {
+                case "yes":
+                    continuation.resume(returning: true) // continue
+                case "no":
+                    continuation.resume(returning: false) // stop resolution
+                default:
+                    self.outputHandler("invalid response: '\(response ?? "")'", false)
+                    continuation.resume(returning: false)
+                }
             }
         }
     }

Sources/Commands/PackageCommands/DumpCommands.swift

@@ -118,7 +118,7 @@ struct DumpPackage: AsyncSwiftCommand {
         let workspace = try swiftCommandState.getActiveWorkspace()
         let root = try swiftCommandState.getWorkspaceRoot()
 
-        let rootManifests = try await workspace.loadRootManifests(
+        let rootManifests = await workspace.loadRootManifests(
             packages: root.packages,
             observabilityScope: swiftCommandState.observabilityScope
         )

Sources/Commands/SwiftTestCommand.swift

@@ -558,7 +558,7 @@ public struct SwiftTestCommand: AsyncSwiftCommand {
     ) async throws {
         let workspace = try swiftCommandState.getActiveWorkspace()
         let root = try swiftCommandState.getWorkspaceRoot()
-        let rootManifests = try await workspace.loadRootManifests(
+        let rootManifests = await workspace.loadRootManifests(
             packages: root.packages,
             observabilityScope: swiftCommandState.observabilityScope
         )
@@ -674,7 +674,7 @@ extension SwiftTestCommand {
     func printCodeCovPath(_ swiftCommandState: SwiftCommandState) async throws {
         let workspace = try swiftCommandState.getActiveWorkspace()
         let root = try swiftCommandState.getWorkspaceRoot()
-        let rootManifests = try await workspace.loadRootManifests(
+        let rootManifests = await workspace.loadRootManifests(
             packages: root.packages,
             observabilityScope: swiftCommandState.observabilityScope
         )

Sources/CoreCommands/SwiftCommandState.swift

@@ -486,7 +486,7 @@ public final class SwiftCommandState {
     public func getRootPackageInformation() async throws -> (dependencies: [PackageIdentity: [PackageIdentity]], targets: [PackageIdentity: [String]]) {
         let workspace = try self.getActiveWorkspace()
         let root = try self.getWorkspaceRoot()
-        let rootManifests = try await workspace.loadRootManifests(
+        let rootManifests = await workspace.loadRootManifests(
             packages: root.packages,
             observabilityScope: self.observabilityScope
         )