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

Integrate information about versions of prebuilt libraries into the solver
and prioritize these versions when making decisions if they meet all of the
requirements of undecided terms.

This helps solver to avoid fetching and at the same time allows partual
matches on prebuilt libraries with fallback to package provided versions.

(cherry picked from commit 6eb042d)
(cherry picked from commit 0e897ed)
(cherry picked from commit ee6a58d)
(cherry picked from commit b817df1)
(cherry picked from commit 2f48249)

Author: xedin

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/PrebuiltPackageContainer.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
+                        )
                     }
                 }
             }