Revert "[PubGrub] Avoid resolving package versions twice in presence of prebuilt libraries (swiftlang#7436)"

This reverts commit f4ab9a4.

Author: xedin

Sources/PackageGraph/CMakeLists.txt

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

Sources/PackageGraph/PrebuiltPackageContainer.swift

@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Basics
+import PackageModel
+import struct TSCUtility.Version
+
+/// A package container that can represent a prebuilt library from a package.
+public struct PrebuiltPackageContainer: PackageContainer {
+    private let chosenIdentity: LibraryMetadata.Identity
+    private let metadata: LibraryMetadata
+
+    public init(metadata: LibraryMetadata) throws {
+        self.metadata = metadata
+
+        // FIXME: Unclear what is supposed to happen if we have multiple identities.
+        if let identity = metadata.identities.first {
+            self.chosenIdentity = identity
+        } else {
+            let name = metadata.productName.map { "'\($0)' " } ?? ""
+            throw InternalError("provided library \(name)does not specifiy any identities")
+        }
+    }
+
+    public var package: PackageReference {
+        return .init(identity: chosenIdentity.identity, kind: chosenIdentity.kind)
+    }
+
+    public func isToolsVersionCompatible(at version: Version) -> Bool {
+        return true
+    }
+
+    public func toolsVersion(for version: Version) throws -> ToolsVersion {
+        return .v4
+    }
+
+    public func toolsVersionsAppropriateVersionsDescending() throws -> [Version] {
+        return try versionsAscending()
+    }
+
+    public func versionsAscending() throws -> [Version] {
+        return [.init(stringLiteral: metadata.version)]
+    }
+
+    public func getDependencies(at version: Version, productFilter: ProductFilter) throws -> [PackageContainerConstraint] {
+        return []
+    }
+
+    public func getDependencies(at revision: String, productFilter: ProductFilter) throws -> [PackageContainerConstraint] {
+        return []
+    }
+
+    public func getUnversionedDependencies(productFilter: ProductFilter) throws -> [PackageContainerConstraint] {
+        return []
+    }
+
+    public func loadPackageReference(at boundVersion: BoundVersion) throws -> PackageReference {
+        return package
+    }
+}

Sources/PackageGraph/Resolution/PubGrub/ContainerProvider.swift

@@ -49,8 +49,8 @@ final class ContainerProvider {
     }
 
     func removeCachedContainers(for packages: [PackageReference]) {
-        for package in packages {
-            self.containersCache[package] = nil
+        packages.forEach {
+            self.containersCache[$0] = nil
         }
     }
 
@@ -65,13 +65,25 @@ 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) {
@@ -81,18 +93,15 @@ final class ContainerProvider {
                 } else {
                     // if prefetch failed, remove from list of prefetches and try again
                     self.prefetches[package] = nil
-                    return self.getContainer(for: package, completion: completion)
+                    return self.getContainer(for: package, availableLibraries: availableLibraries, 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
@@ -109,7 +118,7 @@ final class ContainerProvider {
     /// Starts prefetching the given containers.
     func prefetch(containers identifiers: [PackageReference], availableLibraries: [LibraryMetadata]) {
         let filteredIdentifiers = identifiers.filter {
-            $0.matchingPrebuiltLibrary(in: availableLibraries) == nil
+            return $0.matchingPrebuiltLibrary(in: availableLibraries) == nil
         }
         // Process each container.
         for identifier in filteredIdentifiers {
@@ -124,19 +133,13 @@ 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)
                     }
                 }
             }