[Commands] Add an option to force resolution to Package.resolved

This adds a new flag `--force-resolved-versions` which will force
resolve to versions recorded in the Package.resolved file.

The entries in Package.resolved can be considered as "soft" pins.  Since
the requirements in root manifest and Package.resolved can change
anytime, most SwiftPM operations (that load the package graph) first
check if the current state of things is still correct. However, it is
sometimes useful to force resolve to the dependencies recorded in the
resolved file by entirely bypassing the dependency resolution.

<rdar://problem/45290071> Add option to not re-resolve, but use Package.resolved explicitly

Author: aciidgh

Sources/Commands/Options.swift

@@ -61,5 +61,8 @@ public class ToolOptions {
     /// Whether to enable code coverage.
     public var shouldEnableCodeCoverage = false
 
+    /// Use Package.resolved file for resolving dependencies.
+    public var forceResolvedVersions = false
+
     public required init() {}
 }

Sources/Commands/SwiftTool.swift

@@ -351,6 +351,11 @@ public class SwiftTool<Options: ToolOptions> {
                 usage: "Enable building with the llbuild library"),
             to: { $0.shouldEnableLLBuildLibrary = $1 })
 
+        binder.bind(
+            option: parser.add(option: "--force-resolved-versions", kind: Bool.self,
+                usage: "Force resolve to versions recorded in the Package.resolved file"),
+            to: { $0.forceResolvedVersions = $1 })
+
         // Let subclasses bind arguments.
         type(of: self).defineArguments(parser: parser, binder: binder)
 
@@ -502,7 +507,13 @@ public class SwiftTool<Options: ToolOptions> {
     /// Resolve the dependencies.
     func resolve() throws {
         let workspace = try getActiveWorkspace()
-        workspace.resolve(root: try getWorkspaceRoot(), diagnostics: diagnostics)
+        let root = try getWorkspaceRoot()
+
+        if options.forceResolvedVersions {
+            workspace.resolveToResolvedVersion(root: root, diagnostics: diagnostics)
+        } else {
+            workspace.resolve(root: root, diagnostics: diagnostics)
+        }
 
         // Throw if there were errors when loading the graph.
         // The actual errors will be printed before exiting.
@@ -523,6 +534,7 @@ public class SwiftTool<Options: ToolOptions> {
             let graph = try workspace.loadPackageGraph(
                 root: getWorkspaceRoot(),
                 createREPLProduct: createREPLProduct,
+                forceResolvedVersions: options.forceResolvedVersions,
                 diagnostics: diagnostics
             )
 

Sources/TestSupport/TestWorkspace.swift

@@ -254,13 +254,15 @@ public final class TestWorkspace {
     public func checkPackageGraph(
         roots: [String] = [],
         dependencies: [PackageGraphRootInput.PackageDependency] = [],
+        forceResolvedVersions: Bool = false,
         _ result: (PackageGraph, DiagnosticsEngine) -> ()
     ) {
         let diagnostics = DiagnosticsEngine()
         let workspace = createWorkspace()
         let rootInput = PackageGraphRootInput(
             packages: rootPaths(for: roots), dependencies: dependencies)
-        let graph = workspace.loadPackageGraph(root: rootInput, diagnostics: diagnostics)
+        let graph = workspace.loadPackageGraph(
+            root: rootInput, forceResolvedVersions: forceResolvedVersions, diagnostics: diagnostics)
         result(graph, diagnostics)
     }
 
@@ -379,8 +381,10 @@ public final class TestWorkspace {
                 switch state {
                 case .version(let version):
                     XCTAssertEqual(pin.state.version, version, file: file, line: line)
-                case .revision, .branch:
-                    XCTFail("Unimplemented", file: file, line: line)
+                case .revision(let revision):
+                    XCTAssertEqual(pin.state.revision.identifier, revision, file: file, line: line)
+                case .branch(let branch):
+                    XCTAssertEqual(pin.state.branch, branch, file: file, line: line)
                 }
             case .edited, .local:
                 XCTFail("Unimplemented", file: file, line: line)

Sources/Workspace/Workspace.swift

@@ -588,11 +588,17 @@ extension Workspace {
         root: PackageGraphRootInput,
         createMultipleTestProducts: Bool = false,
         createREPLProduct: Bool = false,
+        forceResolvedVersions: Bool = false,
         diagnostics: DiagnosticsEngine
     ) -> PackageGraph {
 
         // Perform dependency resolution, if required.
-        let manifests = self._resolve(root: root, diagnostics: diagnostics)
+        let manifests: DependencyManifests
+        if forceResolvedVersions {
+            manifests = self._resolveToResolvedVersion(root: root, diagnostics: diagnostics)
+        } else {
+            manifests = self._resolve(root: root, diagnostics: diagnostics)
+        }
         let externalManifests = manifests.allManifests()
 
         // Load the graph.
@@ -1059,6 +1065,73 @@ extension Workspace {
 
 extension Workspace {
 
+    /// Resolves the dependencies according to the entries present in the Package.resolved file.
+    ///
+    /// This method bypasses the dependency resolution and resolves dependencies
+    /// according to the information in the resolved file.
+    public func resolveToResolvedVersion(
+        root: PackageGraphRootInput,
+        diagnostics: DiagnosticsEngine
+    ) {
+        _resolveToResolvedVersion(root: root, diagnostics: diagnostics)
+    }
+
+    /// Resolves the dependencies according to the entries present in the Package.resolved file.
+    ///
+    /// This method bypasses the dependency resolution and resolves dependencies
+    /// according to the information in the resolved file.
+    @discardableResult
+    fileprivate func _resolveToResolvedVersion(
+        root: PackageGraphRootInput,
+        diagnostics: DiagnosticsEngine
+    ) -> DependencyManifests {
+        createCacheDirectories(with: diagnostics)
+
+        let rootManifests = loadRootManifests(packages: root.packages, diagnostics: diagnostics) 
+        let graphRoot = PackageGraphRoot(input: root, manifests: rootManifests)
+
+        // Load the pins store or abort now.
+        guard let pinsStore = diagnostics.wrap({ try self.pinsStore.load() }), !diagnostics.hasErrors else {
+            return loadDependencyManifests(root: graphRoot, diagnostics: diagnostics)
+        }
+
+        // Request all the containers to fetch them in parallel.
+        //
+        // We just request the packages here, repository manager will
+        // automatically manage the parallelism.
+        let pins = pinsStore.pins.map({ $0 })
+        DispatchQueue.concurrentPerform(iterations: pins.count) { idx in
+            _ = try? await {
+                containerProvider.getContainer(for: pins[idx].packageRef, skipUpdate: true, completion: $0) 
+            }
+        }
+
+        // Compute the pins that we need to actually clone.
+        //
+        // We require cloning if there is no checkout or if the checkout doesn't
+        // match with the pin.
+        let requiredPins = pins.filter({ pin in
+            guard let dependency = managedDependencies[forURL: pin.packageRef.path] else {
+                return true
+            }
+            switch dependency.state {
+            case .checkout(let checkoutState):
+                return pin.state != checkoutState
+            case .edited, .local:
+                return true
+            }
+        })
+
+        // Clone the required pins.
+        for pin in requiredPins {
+            diagnostics.wrap {
+                _ = try self.clone(package: pin.packageRef, at: pin.state)
+            }
+        }
+
+        return loadDependencyManifests(root: graphRoot, diagnostics: diagnostics)
+    }
+
     /// Implementation of resolve(root:diagnostics:).
     ///
     /// The extra constraints will be added to the main requirements.

Tests/WorkspaceTests/WorkspaceTests.swift

@@ -2588,6 +2588,108 @@ final class WorkspaceTests: XCTestCase {
              XCTAssertNotNil(ws.managedDependencies[forURL: "/tmp/ws/pkgs/Nested/Foo"])
          }
      }
+
+    func testForceResolveToResolvedVersions() 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", "Bar"]),
+                    ],
+                    products: [],
+                    dependencies: [
+                        TestDependency(name: "Foo", requirement: .upToNextMajor(from: "1.0.0")),
+                        TestDependency(name: "Bar", requirement: .upToNextMajor(from: "1.0.0")),
+                    ]
+                ),
+            ],
+            packages: [
+                TestPackage(
+                    name: "Foo",
+                    targets: [
+                        TestTarget(name: "Foo"),
+                    ],
+                    products: [
+                        TestProduct(name: "Foo", targets: ["Foo"]),
+                    ],
+                    versions: ["1.0.0", "1.2.0", "1.3.2"]
+                ),
+                TestPackage(
+                    name: "Bar",
+                    targets: [
+                        TestTarget(name: "Bar"),
+                    ],
+                    products: [
+                        TestProduct(name: "Bar", targets: ["Bar"]),
+                    ],
+                    versions: ["1.0.0", "develop"]
+                ),
+            ]
+        )
+
+        // Load the initial graph.
+        let deps: [TestWorkspace.PackageDependency] = [
+            .init(name: "Bar", requirement: .revision("develop")),
+        ]
+        workspace.checkPackageGraph(roots: ["Root"], deps: deps) { (graph, diagnostics) in
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.3.2")))
+            result.check(dependency: "bar", at: .checkout(.branch("develop")))
+        }
+        workspace.checkResolved { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.3.2")))
+            result.check(dependency: "bar", at: .checkout(.branch("develop")))
+        }
+
+        // Change pin of foo to something else.
+        do {
+            let ws = workspace.createWorkspace()
+            let pinsStore = try ws.pinsStore.load()
+            let fooPin = pinsStore.pins.first(where: { $0.packageRef.identity == "foo" })!
+
+            let fooRepo = workspace.repoProvider.specifierMap[RepositorySpecifier(url: fooPin.packageRef.path)]!
+            let revision = try fooRepo.resolveRevision(tag: "1.0.0")
+            let newState = CheckoutState(revision: revision, version: "1.0.0")
+
+            pinsStore.pin(packageRef: fooPin.packageRef, state: newState )
+            try pinsStore.saveState()
+        }
+
+        // Check force resolve. This should still produce bar @ develop even
+        // though that requirement is gone.
+        workspace.checkPackageGraph(roots: ["Root"], forceResolvedVersions: true) { (graph, diagnostics) in
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+            result.check(dependency: "bar", at: .checkout(.branch("develop")))
+        }
+        workspace.checkResolved { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+            result.check(dependency: "bar", at: .checkout(.branch("develop")))
+        }
+
+        // A normal resolution.
+        workspace.checkPackageGraph(roots: ["Root"]) { (graph, diagnostics) in
+            XCTAssertNoDiagnostics(diagnostics)
+        }
+        workspace.checkManagedDependencies() { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+            result.check(dependency: "bar", at: .checkout(.version("1.0.0")))
+        }
+        workspace.checkResolved { result in
+            result.check(dependency: "foo", at: .checkout(.version("1.0.0")))
+            result.check(dependency: "bar", at: .checkout(.version("1.0.0")))
+        }
+    }
 }
 
 extension PackageGraph {

Tests/WorkspaceTests/XCTestManifests.swift

@@ -53,6 +53,7 @@ extension WorkspaceTests {
         ("testDependencyResolutionWithEdit", testDependencyResolutionWithEdit),
         ("testDependencySwitchWithSameIdentity", testDependencySwitchWithSameIdentity),
         ("testEditDependency", testEditDependency),
+        ("testForceResolveToResolvedVersions", testForceResolveToResolvedVersions),
         ("testGraphData", testGraphData),
         ("testGraphRootDependencies", testGraphRootDependencies),
         ("testInterpreterFlags", testInterpreterFlags),