[PubGrub] Avoid resolving package versions twice in presence of prebuilt libraries

Sources/PackageGraph/CMakeLists.txt

@@ -19,7 +19,6 @@ add_library(PackageGraph
   PackageGraphRoot.swift
   PackageModel+Extensions.swift
   PackageRequirement.swift
-  PrebuiltPackageContainer.swift
   PinsStore.swift
   Resolution/PubGrub/Assignment.swift
   Resolution/PubGrub/ContainerProvider.swift

Sources/PackageGraph/Resolution/PubGrub/ContainerProvider.swift

@@ -49,8 +49,8 @@ final class ContainerProvider {
     }
 
     func removeCachedContainers(for packages: [PackageReference]) {
-        packages.forEach {
-            self.containersCache[$0] = nil
+        for package in packages {
+            self.containersCache[package] = nil
         }
     }
 
@@ -65,25 +65,13 @@ final class ContainerProvider {
     /// Get the container for the given identifier, loading it if necessary.
     func getContainer(
         for package: PackageReference,
-        availableLibraries: [LibraryMetadata],
         completion: @escaping (Result<PubGrubPackageContainer, Error>) -> Void
     ) {
         // Return the cached container, if available.
         if let container = self.containersCache[comparingLocation: package] {
             return completion(.success(container))
         }
 
-        if let metadata = package.matchingPrebuiltLibrary(in: availableLibraries) {
-            do {
-                let prebuiltPackageContainer = try PrebuiltPackageContainer(metadata: metadata)
-                let pubGrubContainer = PubGrubPackageContainer(underlying: prebuiltPackageContainer, pins: self.pins)
-                self.containersCache[package] = pubGrubContainer
-                return completion(.success(pubGrubContainer))
-            } catch {
-                return completion(.failure(error))
-            }
-        }
-
         if let prefetchSync = self.prefetches[package] {
             // If this container is already being prefetched, wait for that to complete
             prefetchSync.notify(queue: .sharedConcurrent) {
@@ -93,15 +81,18 @@ final class ContainerProvider {
                 } else {
                     // if prefetch failed, remove from list of prefetches and try again
                     self.prefetches[package] = nil
-                    return self.getContainer(for: package, availableLibraries: availableLibraries, completion: completion)
+                    return self.getContainer(for: package, completion: completion)
                 }
             }
         } else {
             // Otherwise, fetch the container from the provider
             self.underlying.getContainer(
                 for: package,
                 updateStrategy: self.skipUpdate ? .never : .always, // TODO: make this more elaborate
-                observabilityScope: self.observabilityScope.makeChildScope(description: "getting package container", metadata: package.diagnosticsMetadata),
+                observabilityScope: self.observabilityScope.makeChildScope(
+                    description: "getting package container",
+                    metadata: package.diagnosticsMetadata
+                ),
                 on: .sharedConcurrent
             ) { result in
                 let result = result.tryMap { container -> PubGrubPackageContainer in
@@ -118,7 +109,7 @@ final class ContainerProvider {
     /// Starts prefetching the given containers.
     func prefetch(containers identifiers: [PackageReference], availableLibraries: [LibraryMetadata]) {
         let filteredIdentifiers = identifiers.filter {
-            return $0.matchingPrebuiltLibrary(in: availableLibraries) == nil
+            $0.matchingPrebuiltLibrary(in: availableLibraries) == nil
         }
         // Process each container.
         for identifier in filteredIdentifiers {
@@ -133,13 +124,19 @@ final class ContainerProvider {
                 self.underlying.getContainer(
                     for: identifier,
                     updateStrategy: self.skipUpdate ? .never : .always, // TODO: make this more elaborate
-                    observabilityScope: self.observabilityScope.makeChildScope(description: "prefetching package container", metadata: identifier.diagnosticsMetadata),
+                    observabilityScope: self.observabilityScope.makeChildScope(
+                        description: "prefetching package container",
+                        metadata: identifier.diagnosticsMetadata
+                    ),
                     on: .sharedConcurrent
                 ) { result in
                     defer { self.prefetches[identifier]?.leave() }
                     // only cache positive results
                     if case .success(let container) = result {
-                        self.containersCache[identifier] = PubGrubPackageContainer(underlying: container, pins: self.pins)
+                        self.containersCache[identifier] = PubGrubPackageContainer(
+                            underlying: container,
+                            pins: self.pins
+                        )
                     }
                 }
             }