Merge pull request #2575 from aciidb0mb3r/resolved-file-5.2

[Resolver] Don't prefetch overridden packages

Author: aciidgh

Sources/PackageGraph/Pubgrub.swift

@@ -905,12 +905,6 @@ public final class PubgrubDependencyResolver {
         self.root = root
         self.pinsMap = pinsMap
 
-        // Prefetch the containers if prefetching is enabled.
-        if isPrefetchingEnabled {
-            let pins = pinsMap.values.map{ $0.packageRef }
-            self.provider.prefetch(containers: pins)
-        }
-
         // Add the root incompatibility.
         let rootIncompatibility = Incompatibility(
             terms: [Term(not: root, .exact("1.0.0"))],
@@ -921,6 +915,17 @@ public final class PubgrubDependencyResolver {
         let inputs = try processInputs(with: constraints)
         self.overriddenPackages = inputs.overriddenPackages
 
+        // Prefetch the containers if prefetching is enabled.
+        if isPrefetchingEnabled {
+            // We avoid prefetching packages that are overridden since
+            // otherwise we'll end up creating a repository container
+            // for them.
+            let pins = pinsMap.values
+                .map{ $0.packageRef }
+                .filter{ !overriddenPackages.keys.contains($0) }
+            self.provider.prefetch(containers: pins)
+        }
+
         // Add all the root incompatibilities.
         for incompat in inputs.rootIncompatibilities {
             add(incompat, location: .topLevel)

Sources/SPMTestSupport/TestWorkspace.swift

@@ -154,6 +154,7 @@ public final class TestWorkspace {
             config: config,
             fileSystem: fs,
             repositoryProvider: repoProvider,
+            isResolverPrefetchingEnabled: true,
             enablePubgrubResolver: enablePubGrub,
             skipUpdate: skipUpdate
         )

Tests/WorkspaceTests/WorkspaceTests.swift

@@ -2419,6 +2419,90 @@ final class WorkspaceTests: XCTestCase {
         }
     }
 
+    func testPrefetchingWithOverridenPackage() throws {
+        let sandbox = AbsolutePath("/tmp/ws/")
+        let fs = InMemoryFileSystem()
+
+        let workspace = try TestWorkspace(
+            sandbox: sandbox,
+            fs: fs,
+            roots: [
+                TestPackage(
+                    name: "Root",
+                    targets: [
+                        TestTarget(name: "Root", dependencies: ["Foo"]),
+                    ],
+                    products: [],
+                    dependencies: [
+                        TestDependency(name: "Foo", requirement: .upToNextMajor(from: "1.0.0")),
+                    ]
+                ),
+            ],
+            packages: [
+                TestPackage(
+                    name: "Foo",
+                    targets: [
+                        TestTarget(name: "Foo"),
+                    ],
+                    products: [
+                        TestProduct(name: "Foo", targets: ["Foo"]),
+                    ],
+                    versions: ["1.0.0"]
+                ),
+                TestPackage(
+                    name: "Foo",
+                    targets: [
+                        TestTarget(name: "Foo", dependencies: ["Bar"]),
+                    ],
+                    products: [
+                        TestProduct(name: "Foo", targets: ["Foo"]),
+                    ],
+                    dependencies: [
+                        TestDependency(name: "Bar", requirement: .upToNextMajor(from: "1.0.0")),
+                    ],
+                    versions: [nil]
+                ),
+                TestPackage(
+                    name: "Bar",
+                    targets: [
+                        TestTarget(name: "Bar"),
+                    ],
+                    products: [
+                        TestProduct(name: "Bar", targets: ["Bar"]),
+                    ],
+                    versions: ["1.0.0"]
+                ),
+            ]
+        )
+
+        // Load the graph.
+        workspace.checkPackageGraph(roots: ["Root"]) { (graph, diagnostics) in
+            PackageGraphTester(graph) { result in
+                result.check(roots: "Root")
+                result.check(packages: "Foo", "Root")
+            }
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+        }
+
+        let deps: [TestWorkspace.PackageDependency] = [
+            .init(name: "Foo", requirement: .localPackage),
+        ]
+        workspace.checkPackageGraph(roots: ["Root"], deps: deps) { (graph, diagnostics) in
+            PackageGraphTester(graph) { result in
+                result.check(roots: "Root")
+                result.check(packages: "Foo", "Bar", "Root")
+            }
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .local)
+            result.check(dependency: "bar", at: .checkout(.version("1.0.0")))
+        }
+    }
+
     // Test that changing a particular dependency re-resolves the graph.
     func testChangeOneDependency() throws {
         let sandbox = AbsolutePath("/tmp/ws/")

Tests/WorkspaceTests/XCTestManifests.swift

@@ -81,6 +81,7 @@ extension WorkspaceTests {
         ("testPrecomputeResolution_requirementChange_versionToBranch", testPrecomputeResolution_requirementChange_versionToBranch),
         ("testPrecomputeResolution_requirementChange_versionToLocal", testPrecomputeResolution_requirementChange_versionToLocal),
         ("testPrecomputeResolution_requirementChange_versionToRevision", testPrecomputeResolution_requirementChange_versionToRevision),
+        ("testPrefetchingWithOverridenPackage", testPrefetchingWithOverridenPackage),
         ("testResolutionFailureWithEditedDependency", testResolutionFailureWithEditedDependency),
         ("testResolve", testResolve),
         ("testResolvedFileUpdate", testResolvedFileUpdate),