Reduce usage of callback and dispatch methods in favor of async/await

Sources/PackageRegistry/ChecksumTOFU.swift

@@ -67,29 +67,6 @@ struct PackageVersionChecksumTOFU {
         }
     }
 
-    @available(*, noasync, message: "Use the async alternative")
-    func validateSourceArchive(
-        registry: Registry,
-        package: PackageIdentity.RegistryIdentity,
-        version: Version,
-        checksum: String,
-        timeout: DispatchTimeInterval?,
-        observabilityScope: ObservabilityScope,
-        callbackQueue: DispatchQueue,
-        completion: @escaping @Sendable (Result<Void, Error>) -> Void
-    ) {
-        callbackQueue.asyncResult(completion) {
-            try await self.validateSourceArchive(
-                registry: registry,
-                package: package,
-                version: version,
-                checksum: checksum,
-                timeout: timeout,
-                observabilityScope: observabilityScope
-            )
-        }
-    }
-
     private func getExpectedChecksum(
         registry: Registry,
         package: PackageIdentity.RegistryIdentity,

Sources/PackageRegistry/RegistryClient.swift

@@ -613,25 +613,6 @@ public final class RegistryClient: AsyncCancellable {
         }
     }
 
-    @available(*, deprecated, message: "Use the async alternative")
-    public func getAvailableManifests(
-        package: PackageIdentity,
-        version: Version,
-        timeout: DispatchTimeInterval? = .none,
-        observabilityScope: ObservabilityScope,
-        callbackQueue: DispatchQueue,
-        completion: @escaping @Sendable (Result<[String: (toolsVersion: ToolsVersion, content: String?)], Error>) -> Void
-    ) {
-        callbackQueue.asyncResult(completion) {
-            try await self.getAvailableManifests(
-                package: package,
-                version: version,
-                timeout: timeout,
-                observabilityScope: observabilityScope
-            )
-        }
-    }
-
     public func getManifestContent(
         package: PackageIdentity,
         version: Version,

Sources/PackageRegistry/RegistryDownloadsManager.swift

@@ -121,25 +121,6 @@ public class RegistryDownloadsManager: AsyncCancellable {
         return try await task.value
     }
 
-    @available(*, noasync, message: "Use the async alternative")
-    public func lookup(
-        package: PackageIdentity,
-        version: Version,
-        observabilityScope: ObservabilityScope,
-        delegateQueue: DispatchQueue,
-        callbackQueue: DispatchQueue,
-        completion: @escaping @Sendable (Result<Basics.AbsolutePath, Error>) -> Void
-    ) {
-        callbackQueue.asyncResult(completion) {
-            try await self.lookup(
-                package: package,
-                version: version,
-                observabilityScope: observabilityScope,
-                delegateQueue: delegateQueue
-            )
-        }
-    }
-
     /// Cancel any outstanding requests
     public func cancel(deadline: DispatchTime) async throws {
         try await self.registryClient.cancel(deadline: deadline)

Sources/PackageRegistry/SignatureValidation.swift

@@ -350,36 +350,6 @@ struct SignatureValidation {
         return signingEntity;
     }
 
-
-    @available(*, noasync, message: "Use the async alternative")
-    func validate(
-        registry: Registry,
-        package: PackageIdentity.RegistryIdentity,
-        version: Version,
-        toolsVersion: ToolsVersion?,
-        manifestContent: String,
-        configuration: RegistryConfiguration.Security.Signing,
-        timeout: DispatchTimeInterval?,
-        fileSystem: FileSystem,
-        observabilityScope: ObservabilityScope,
-        callbackQueue: DispatchQueue,
-        completion: @escaping @Sendable (Result<SigningEntity?, Error>) -> Void
-    ) {
-        callbackQueue.asyncResult(completion) {
-            try await self.validate(
-                registry: registry,
-                package: package,
-                version: version,
-                toolsVersion: toolsVersion,
-                manifestContent: manifestContent,
-                configuration: configuration,
-                timeout: timeout,
-                fileSystem: fileSystem,
-                observabilityScope: observabilityScope
-            )
-        }
-    }
-
     private func getAndValidateManifestSignature(
         registry: Registry,
         package: PackageIdentity.RegistryIdentity,

Sources/PackageRegistry/SigningEntityTOFU.swift

@@ -76,26 +76,6 @@ struct PackageSigningEntityTOFU {
         )
     }
 
-    @available(*, noasync, message: "Use the async alternative")
-    func validate(
-        registry: Registry,
-        package: PackageIdentity.RegistryIdentity,
-        version: Version,
-        signingEntity: SigningEntity?,
-        observabilityScope: ObservabilityScope,
-        completion: @escaping @Sendable (Result<Void, Error>) -> Void
-    ) {
-        DispatchQueue.sharedConcurrent.asyncResult(completion) {
-            try await self.validate(
-                registry: registry,
-                package: package,
-                version: version,
-                signingEntity: signingEntity,
-                observabilityScope: observabilityScope
-            )
-        }
-    }
-
     private func validateSigningEntity(
         registry: Registry,
         package: PackageIdentity.RegistryIdentity,

Sources/SourceControl/RepositoryManager.swift

@@ -97,8 +97,7 @@ public class RepositoryManager: Cancellable {
         repository: RepositorySpecifier,
         updateStrategy: RepositoryUpdateStrategy,
         observabilityScope: ObservabilityScope,
-        delegateQueue: DispatchQueue,
-        callbackQueue: DispatchQueue
+        delegateQueue: DispatchQueue
     ) async throws -> RepositoryHandle {
         try await withCheckedThrowingContinuation { continuation in
             self.lookup(
@@ -107,7 +106,7 @@ public class RepositoryManager: Cancellable {
                 updateStrategy: updateStrategy,
                 observabilityScope: observabilityScope,
                 delegateQueue: delegateQueue,
-                callbackQueue: callbackQueue,
+                callbackQueue: .sharedConcurrent,
                 completion: { continuation.resume(with: $0) }
             )
         }

Sources/Workspace/Workspace+Dependencies.swift

@@ -19,7 +19,6 @@ import func Basics.os_signpost
 import struct Basics.RelativePath
 import enum Basics.SignpostName
 import class Basics.ThreadSafeKeyValueStore
-import class Dispatch.DispatchGroup
 import struct Dispatch.DispatchTime
 import enum Dispatch.DispatchTimeInterval
 import struct PackageGraph.Assignment

Sources/Workspace/Workspace+Editing.swift

@@ -105,8 +105,7 @@ extension Workspace {
                 repository: repository,
                 updateStrategy: .never,
                 observabilityScope: observabilityScope,
-                delegateQueue: .sharedConcurrent,
-                callbackQueue: .sharedConcurrent
+                delegateQueue: .sharedConcurrent
             )
             let repo = try handle.open()
 

Sources/Workspace/Workspace+Manifests.swift

@@ -19,7 +19,6 @@ import struct Basics.InternalError
 import class Basics.ObservabilityScope
 import struct Basics.SwiftVersion
 import class Basics.ThreadSafeKeyValueStore
-import class Dispatch.DispatchGroup
 import struct Dispatch.DispatchTime
 import struct OrderedCollections.OrderedDictionary
 import struct OrderedCollections.OrderedSet
@@ -1045,17 +1044,13 @@ extension Workspace {
         case .fileSystem:
             return nil
         case .custom:
-            let container = try await withCheckedThrowingContinuation { continuation in
-                self.packageContainerProvider.getContainer(
-                    for: package,
-                    updateStrategy: .never,
-                    observabilityScope: observabilityScope,
-                    on: .sharedConcurrent,
-                    completion: {
-                        continuation.resume(with: $0)
-                    }
-                )
-            }
+            let container = try await self.packageContainerProvider.getContainer(
+                for: package,
+                updateStrategy: .never,
+                observabilityScope: observabilityScope,
+                on: .sharedConcurrent
+            )
+
             guard let customContainer = container as? CustomPackageContainer else {
                 observabilityScope.emit(error: "invalid custom dependency container: \(container)")
                 return nil

Sources/Workspace/Workspace+SourceControl.swift

@@ -178,8 +178,7 @@ extension Workspace {
             repository: repository,
             updateStrategy: .never,
             observabilityScope: observabilityScope,
-            delegateQueue: .sharedConcurrent,
-            callbackQueue: .sharedConcurrent
+            delegateQueue: .sharedConcurrent
         )
 
         // Clone the repository into the checkouts.

Sources/Workspace/Workspace.swift

@@ -1263,24 +1263,6 @@ extension Workspace {
         return try builder.construct()
     }
 
-    /// Loads a single package in the context of a previously loaded graph. This can be useful for incremental loading
-    /// in a longer-lived program, like an IDE.
-    @available(*, noasync, message: "Use the async alternative")
-    public func loadPackage(
-        with identity: PackageIdentity,
-        packageGraph: ModulesGraph,
-        observabilityScope: ObservabilityScope,
-        completion: @escaping @Sendable (Result<Package, Error>) -> Void
-    ) {
-        DispatchQueue.sharedConcurrent.asyncResult(completion) {
-            try await self.loadPackage(
-                with: identity,
-                packageGraph: packageGraph,
-                observabilityScope: observabilityScope
-            )
-        }
-    }
-
     public func changeSigningEntityFromVersion(
         package: PackageIdentity,
         version: Version,

Sources/_InternalTestSupport/MockWorkspace.swift

@@ -216,17 +216,12 @@ public final class MockWorkspace {
                         identity: PackageIdentity(url: url),
                         kind: .remoteSourceControl(url)
                     )
-                    let container = try await withCheckedThrowingContinuation { continuation in
-                        containerProvider.getContainer(
-                            for: packageRef,
-                            updateStrategy: .never,
-                            observabilityScope: observability.topScope,
-                            on: .sharedConcurrent,
-                            completion: {
-                                continuation.resume(with: $0)
-                            }
-                        )
-                    }
+                    let container = try await containerProvider.getContainer(
+                        for: packageRef,
+                        updateStrategy: .never,
+                        observabilityScope: observability.topScope,
+                        on: .sharedConcurrent
+                    )
                     guard let customContainer = container as? CustomPackageContainer else {
                         throw StringError("invalid custom container: \(container)")
                     }

Tests/BasicsTests/AsyncProcessTests.swift

@@ -66,31 +66,21 @@ final class AsyncProcessTests: XCTestCase {
         }
     }
 
-    func testPopenLegacyAsync() throws {
+    func testPopenLegacyAsync() async throws {
         #if os(Windows)
         let args = ["where.exe", "where"]
         let answer = "C:\\Windows\\System32\\where.exe"
         #else
         let args = ["whoami"]
         let answer = NSUserName()
         #endif
-        var popenResult: Result<AsyncProcessResult, Error>?
-        let group = DispatchGroup()
-        group.enter()
-        AsyncProcess.popen(arguments: args) { result in
-            popenResult = result
-            group.leave()
-        }
-        group.wait()
-        switch popenResult {
-        case .success(let processResult):
-            let output = try processResult.utf8Output()
-            XCTAssertTrue(output.hasPrefix(answer))
-        case .failure(let error):
-            XCTFail("error = \(error)")
-        case nil:
-            XCTFail()
+        let processResult = try await withCheckedThrowingContinuation { continuation in
+            AsyncProcess.popen(arguments: args) { result in
+                continuation.resume(with: result)
+            }
         }
+        let output = try processResult.utf8Output()
+        XCTAssert(output.hasPrefix(answer))
     }
 
     @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)

Tests/FunctionalTests/PluginTests.swift

@@ -550,8 +550,7 @@ final class PluginTests: XCTestCase {
                     )
 
                     let toolSearchDirectories = [try UserToolchain.default.swiftCompilerPath.parentDirectory]
-                    let success = try await withCheckedThrowingContinuation { continuation in
-                      plugin.invoke(
+                    let success = try await plugin.invoke(
                         action: .performCommand(package: package, arguments: arguments),
                         buildEnvironment: BuildEnvironment(platform: .macOS, configuration: .debug),
                         scriptRunner: scriptRunner,
@@ -568,12 +567,8 @@ final class PluginTests: XCTestCase {
                         modulesGraph: packageGraph,
                         observabilityScope: observability.topScope,
                         callbackQueue: delegateQueue,
-                        delegate: delegate,
-                        completion: {
-                          continuation.resume(with: $0)
-                        }
-                      )
-                    }
+                        delegate: delegate
+                    )
                     if expectFailure {
                         XCTAssertFalse(success, "expected command to fail, but it succeeded", file: file, line: line)
                     }