Use existing AsyncThrowingValueMemoizer in favour of AsyncMemoizableThreadSafeBox

Author: plemarquand

Sources/Basics/Concurrency/ThreadSafeBox.swift

@@ -222,92 +222,3 @@ extension ThreadSafeBox where Value == String {
 }
 
 extension ThreadSafeBox: @unchecked Sendable where Value: Sendable {}
-
-/// Thread-safe value boxing structure that provides synchronized asynchronous memoization of a wrapped value.
-public final class AsyncMemoizableThreadSafeBox<Value: Sendable>: @unchecked Sendable {
-    private var underlying: Value?
-    private let lock = NSLock()
-    private let asyncCoordination = AsyncMemoizationCoordinator<Value>()
-
-    public init() {}
-
-    /// Atomically retrieves the current value from the box.
-    ///
-    /// - Returns: The current value stored in the box, or nil if none is present.
-    public func get() -> Value? {
-        self.lock.withLock {
-            self.underlying
-        }
-    }
-
-    /// Atomically computes and caches a value produced by an async function, if not already present.
-    ///
-    /// If the box already contains a non-nil value that value is returned immediately.
-    /// Otherwise, the provided async closure is executed to compute the value, which is then
-    /// stored and returned.
-    ///
-    /// Concurrent calls to memoize will wait for the first call to complete and receive its result.
-    /// If the body throws an error, all pending calls receive that error and the state is reset.
-    ///
-    /// - Parameter body: An async closure that computes the value to store if none exists.
-    /// - Returns: The cached value or the newly computed value.
-    /// - Throws: Any error thrown by the computation closure.
-    @discardableResult
-    public func memoize(body: @Sendable @escaping () async throws -> Value) async throws -> Value {
-        if let value = self.get() {
-            return value
-        }
-
-        // Try to register as the executor, or get the existing task
-        let task: Task<Value, Error> = await self.asyncCoordination.getOrCreateTask {
-            // This closure is only called by the first caller
-            Task<Value, Error> {
-                // Double-check after acquiring coordination
-                if let value = self.get() {
-                    return value
-                }
-
-                let value = try await body()
-
-                // Store the value
-                self.lock.withLock {
-                    self.underlying = value
-                }
-                return value
-            }
-        }
-
-        // Everyone (including the first caller) awaits the same task
-        do {
-            let result = try await task.value
-            await self.asyncCoordination.clearTask()
-            return result
-        } catch {
-            await self.asyncCoordination.clearTask()
-            throw error
-        }
-    }
-
-    // Actor for coordinating async memoization within a thread safe box
-    private actor AsyncMemoizationCoordinator<T: Sendable>: Sendable {
-        private var inProgressTask: Task<T, Error>?
-
-        /// Returns an existing task if one is in progress, or creates and stores a new one
-        func getOrCreateTask(_ createTask: @Sendable () -> Task<T, Error>) -> Task<T, Error> {
-            if let existingTask = inProgressTask {
-                return existingTask
-            }
-
-            // We're the first - create and store the task
-            let task = createTask()
-            inProgressTask = task
-            return task
-        }
-
-        /// Clears the current task
-        func clearTask() {
-            inProgressTask = nil
-        }
-    }
-}
-

Sources/Build/BuildOperation.swift

@@ -171,10 +171,10 @@ public final class BuildOperation: PackageStructureDelegate, SPMBuildCore.BuildS
     }
 
     /// The build description resulting from planing.
-    private let buildDescription = AsyncMemoizableThreadSafeBox<BuildDescription>()
+    private let buildDescription = AsyncThrowingValueMemoizer<BuildDescription>()
 
     /// The loaded package graph.
-    private let packageGraph = AsyncMemoizableThreadSafeBox<ModulesGraph>()
+    private let packageGraph = AsyncThrowingValueMemoizer<ModulesGraph>()
 
     /// File system to operate on.
     private var fileSystem: Basics.FileSystem {

Sources/Workspace/PackageContainer/FileSystemPackageContainer.swift

@@ -39,7 +39,7 @@ public struct FileSystemPackageContainer: PackageContainer {
     private let observabilityScope: ObservabilityScope
 
     /// cached version of the manifest
-    private let manifest = AsyncMemoizableThreadSafeBox<Manifest>()
+    private let manifest = AsyncThrowingValueMemoizer<Manifest>()
 
     public init(
         package: PackageReference,

Sources/Workspace/PackageContainer/RegistryPackageContainer.swift

@@ -31,7 +31,7 @@ public class RegistryPackageContainer: PackageContainer {
     private let currentToolsVersion: ToolsVersion
     private let observabilityScope: ObservabilityScope
 
-    private var knownVersionsCache = AsyncMemoizableThreadSafeBox<[Version]>()
+    private var knownVersionsCache = AsyncThrowingValueMemoizer<[Version]>()
     private var toolsVersionsCache = ThrowingAsyncKeyValueMemoizer<Version, ToolsVersion>()
     private var validToolsVersionsCache = AsyncKeyValueMemoizer<Version, Bool>()
     private var manifestsCache = ThrowingAsyncKeyValueMemoizer<Version, Manifest>()