Merge pull request #1163 from aciidb0mb3r/auto-resolve

[Workspace] Move pin subcommand to resolve

Author: aciidgh

Sources/Commands/SwiftPackageTool.swift

@@ -82,11 +82,27 @@ public class SwiftPackageTool: SwiftTool<PackageToolOptions> {
 
         case .fetch:
             diagnostics.emit(data: FetchDeprecatedDiagnostic())
-            fallthrough
+            let workspace = try getActiveWorkspace()
+            workspace.resolve(root: try getWorkspaceRoot(), diagnostics: diagnostics)
 
         case .resolve:
+            let resolveOptions = options.resolveOptions
             let workspace = try getActiveWorkspace()
-            workspace.resolve(root: try getWorkspaceRoot(), diagnostics: diagnostics)
+            let root = try getWorkspaceRoot()
+
+            // If a package is provided, use that to resolve the dependencies.
+            if let packageName = resolveOptions.packageName {
+                return try workspace.resolve(
+                    packageName: packageName,
+                    root: getWorkspaceRoot(),
+                    version: resolveOptions.version.flatMap(Version.init(string:)),
+                    branch: resolveOptions.branch,
+                    revision: resolveOptions.revision,
+                    diagnostics: diagnostics)
+            }
+
+            // Otherwise, run a normal resolve.
+            workspace.resolve(root: root, diagnostics: diagnostics)
 
         case .edit:
             let packageName = options.editOptions.packageName!
@@ -180,38 +196,9 @@ public class SwiftPackageTool: SwiftTool<PackageToolOptions> {
 
         case .help:
             parser.printUsage(on: stdoutStream)
-
-        case .pin:
-            let pinOptions = options.pinOptions
-            // Ensure we have the package name.
-            guard let packageName = pinOptions.packageName else {
-                throw PackageToolOperationError.insufficientOptions(usage: pinUsage)
-            }
-
-            // Load the package graph.
-            try loadPackageGraph()
-
-            let workspace = try getActiveWorkspace()
-
-            // Pin the dependency.
-            try workspace.pin(
-                packageName: packageName,
-                root: getWorkspaceRoot(),
-                version: pinOptions.version.flatMap(Version.init(string:)),
-                branch: pinOptions.branch,
-                revision: pinOptions.revision,
-                diagnostics: diagnostics)
         }
     }
 
-    var pinUsage: String {
-        let stream = BufferedOutputByteStream()
-        stream <<< "Expected package pin format:\n"
-        stream <<< "swift package pin (--all | <packageName> [--version <version>])\n"
-        stream <<< "Note: Either provide a package to pin or provide pin all option to pin all dependencies."
-        return stream.bytes.asString!
-    }
-
     override class func defineArguments(parser: ArgumentParser, binder: ArgumentBinder<PackageToolOptions>) {
         binder.bind(
             option: parser.add(option: "--version", kind: Bool.self),
@@ -251,12 +238,11 @@ public class SwiftPackageTool: SwiftTool<PackageToolOptions> {
 
         parser.add(subparser: PackageMode.clean.rawValue, overview: "Delete build artifacts")
         parser.add(subparser: PackageMode.fetch.rawValue, overview: "")
-        parser.add(subparser: PackageMode.resolve.rawValue, overview: "Resolve package dependencies")
         parser.add(subparser: PackageMode.reset.rawValue, overview: "Reset the complete cache/build directory")
 
-        let resolveParser = parser.add(subparser: PackageMode.resolveTool.rawValue, overview: "")
+        let resolveToolParser = parser.add(subparser: PackageMode.resolveTool.rawValue, overview: "")
         binder.bind(
-            option: resolveParser.add(
+            option: resolveToolParser.add(
                 option: "--type", kind: PackageToolOptions.ResolveToolMode.self,
                 usage: "text|json"),
             to: { $0.resolveToolMode = $1 })
@@ -332,29 +318,29 @@ public class SwiftPackageTool: SwiftTool<PackageToolOptions> {
                 $0.outputPath = $3?.path
             })
 
-        let pinParser = parser.add(
-            subparser: PackageMode.pin.rawValue,
-            overview: "Perform pinning operations on a package.")
+        let resolveParser = parser.add(
+            subparser: PackageMode.resolve.rawValue,
+            overview: "Resolve package dependencies")
         binder.bind(
-            positional: pinParser.add(
+            positional: resolveParser.add(
                 positional: "name", kind: String.self, optional: true,
-                usage: "The name of the package to pin"),
-            to: { $0.pinOptions.packageName = $1 })
+                usage: "The name of the package to resolve"),
+            to: { $0.resolveOptions.packageName = $1 })
 
         binder.bind(
-            pinParser.add(
+            resolveParser.add(
                 option: "--version", kind: String.self,
-                usage: "The version to pin at"),
-            pinParser.add(
+                usage: "The version to resolve at"),
+            resolveParser.add(
                 option: "--branch", kind: String.self,
-                usage: "The branch to pin at"),
-            pinParser.add(
+                usage: "The branch to resolve at"),
+            resolveParser.add(
                 option: "--revision", kind: String.self,
-                usage: "The revision to pin at"),
+                usage: "The revision to resolve at"),
             to: {
-                $0.pinOptions.version = $1
-                $0.pinOptions.branch = $2
-                $0.pinOptions.revision = $3 })
+                $0.resolveOptions.version = $1
+                $0.resolveOptions.branch = $2
+                $0.resolveOptions.revision = $3 })
 
         binder.bind(
             parser: parser,
@@ -384,13 +370,13 @@ public class PackageToolOptions: ToolOptions {
     var outputPath: AbsolutePath?
     var xcodeprojOptions = XcodeprojOptions()
 
-    struct PinOptions {
+    struct ResolveOptions {
         var packageName: String?
         var version: String?
         var revision: String?
         var branch: String?
     }
-    var pinOptions = PinOptions()
+    var resolveOptions = ResolveOptions()
 
     enum ResolveToolMode: String {
         case text
@@ -414,7 +400,6 @@ public enum PackageMode: String, StringEnumArgument {
     case fetch
     case generateXcodeproj = "generate-xcodeproj"
     case initPackage = "init"
-    case pin
     case reset
     case resolve
     case resolveTool = "resolve-tool"

Sources/Workspace/PinsStore.swift

@@ -99,10 +99,17 @@ public final class PinsStore {
         )
     }
 
-	/// Pin a managed dependency at its checkout state.
-	///
-	/// This method does nothing if the dependency is in edited state.
-	func pin(_ dependency: ManagedDependency) {
+    /// Add a pin.
+    ///
+    /// This will replace any previous pin with same package name.
+    public func add(_ pin: Pin) {
+        pinsMap[pin.package] = pin
+    }
+
+    /// Pin a managed dependency at its checkout state.
+    ///
+    /// This method does nothing if the dependency is in edited state.
+    func pin(_ dependency: ManagedDependency) {
 
         // Get the checkout state.
         let checkoutState: CheckoutState
@@ -117,7 +124,7 @@ public final class PinsStore {
             package: dependency.name,
             repository: dependency.repository,
             state: checkoutState)
-	}
+    }
 
     /// Unpin all of the currently pinnned dependencies.
     ///

Sources/Workspace/Workspace.swift

@@ -339,22 +339,21 @@ extension Workspace {
         try unedit(dependency: dependency, forceRemove: forceRemove)
     }
 
-    /// Pins a package at a given state.
+    /// Resolve a package at the given state.
     ///
     /// Only one of version, branch and revision will be used and in the same
     /// order. If none of these is provided, the dependency will be pinned at
     /// the current checkout state.
     ///
     /// - Parameters:
-    ///   - dependency: The dependency to pin.
-    ///   - packageName: The name of the package which is being pinned.
+    ///   - packageName: The name of the package which is being resolved.
     ///   - root: The workspace's root input.
     ///   - version: The version to pin at.
     ///   - branch: The branch to pin at.
     ///   - revision: The revision to pin at.
     ///   - diagnostics: The diagnostics engine that reports errors, warnings
     ///     and notes.
-    public func pin(
+    public func resolve(
         packageName: String,
         root: WorkspaceRoot,
         version: Version? = nil,
@@ -371,72 +370,27 @@ extension Workspace {
             return diagnostics.emit(error)
         }
 
-        // Compute the requirement.
-        let requirement: RepositoryPackageConstraint.Requirement
+        // Compute the checkout state.
+        //
+        // We use a dummy revision in case of version and branch because we
+        // might not know the needed revision at this point.
+        let checkoutState: CheckoutState
         if let version = version {
-            requirement = .versionSet(.exact(version))
+            checkoutState = CheckoutState(revision: Revision(identifier: ""), version: version)
         } else if let branch = branch {
-            requirement = .revision(branch)
+            checkoutState = CheckoutState(revision: Revision(identifier: ""), branch: branch)
         } else if let revision = revision {
-            requirement = .revision(revision)
+            checkoutState = CheckoutState(revision: Revision(identifier: revision))
         } else {
-            requirement = currentState.requirement()
-        }
-
-        // Load the root manifests and currently checked out manifests.
-        let rootManifests = loadRootManifests(packages: root.packages, diagnostics: diagnostics) 
-
-        // Load the current manifests.
-        let graphRoot = PackageGraphRoot(manifests: rootManifests, dependencies: root.dependencies)
-        let currentManifests = loadDependencyManifests(root: graphRoot, diagnostics: diagnostics)
-
-        // Abort if we're unable to load the pinsStore or have any diagnostics.
-        guard let pinsStore = diagnostics.wrap({ try self.pinsStore.load() }) else {
-            return
+            checkoutState = currentState
         }
 
-        // Ensure we don't have any error at this point.
-        guard !diagnostics.hasErrors else { return }
+        // Create a pin with above checkout state.
+        let pin = PinsStore.Pin(
+            package: dependency.name, repository: dependency.repository, state: checkoutState)
 
-        // Compute constraints with the new pin and try to resolve
-        // dependencies. We only commit the pin if the dependencies can be
-        // resolved with new constraints.
-        //
-        // The constraints consist of three things:
-        // * Unversioned constraints for edited packages.
-        // * Root manifest contraints.
-        // * Exisiting pins except the dependency we're currently pinning.
-        // * The constraint for the new pin we're trying to add.
-        var constraints = currentManifests.editedPackagesConstraints()
-        constraints += graphRoot.constraints
-
-        var pins = pinsStore.createConstraints().filter({ $0.identifier != dependency.repository })
-        pins.append(
-            RepositoryPackageConstraint(
-                container: dependency.repository, requirement: requirement))
-
-        // Resolve the dependencies.
-        let results = resolveDependencies(dependencies: constraints, pins: pins, diagnostics: diagnostics)
-        guard !diagnostics.hasErrors else { return }
-
-        // Update the checkouts based on new dependency resolution.
-        updateCheckouts(with: results, diagnostics: diagnostics)
-        guard !diagnostics.hasErrors else { return }
-
-        // Get the updated dependency.
-        let newDependency = managedDependencies[dependency.repository]!
-
-        // Assert that the dependency is at the pinned checkout state now.
-        if case .checkout(let checkoutState) = newDependency.state {
-            assert(checkoutState.requirement() == requirement)
-        } else {
-            assertionFailure()
-        }
-
-        // Update the pins store.
-        self.pinAll(
-             pinsStore: pinsStore,
-             diagnostics: diagnostics)
+        // Run the resolution.
+        _resolve(root: root, extraPins: [pin], diagnostics: diagnostics)
     }
 
     /// Cleans the build artefacts from workspace data.
@@ -574,7 +528,7 @@ extension Workspace {
         root: WorkspaceRoot,
         diagnostics: DiagnosticsEngine
     ) {
-        _ = _resolve(root: root, diagnostics: diagnostics)
+        _resolve(root: root, diagnostics: diagnostics)
     }
 
 	/// Load the package graph data.
@@ -910,10 +864,18 @@ extension Workspace {
 extension Workspace {
 
     /// Implementation of resolve(root:diagnostics:).
+    ///
+    /// The extra pins will override the pin of the same package in the
+    /// pinsStore.  It is useful in situations where a requirement is being
+    /// imposed outside of manifest and pins file. E.g., when using a command
+    /// like `$ swift package resolve foo --version 1.0.0`.
+    @discardableResult
     fileprivate func _resolve(
         root: WorkspaceRoot,
+        extraPins: [PinsStore.Pin] = [],
         diagnostics: DiagnosticsEngine
     ) -> DependencyManifests {
+
         // Ensure the cache path exists and validate that edited dependencies.
         createCacheDirectories(with: diagnostics)
 
@@ -937,11 +899,16 @@ extension Workspace {
 
         // Compute if we need to run the resolver.
         if missingURLs.isEmpty {
+            // Use root constraints, dependency manifest constraints and extra
+            // pins to compute if a new resolution is required.
             let dependencies = graphRoot.constraints + currentManifests.dependencyConstraints()
+            extraPins.forEach(pinsStore.add)
+
             let result = isResolutionRequired(dependencies: dependencies, pinsStore: pinsStore)
 
-            // We're done if we don't need resolution.
-            guard result.resolve else {
+            // If we don't need resolution, just validate pinsStore and return.
+            if !result.resolve {
+                validatePinsStore(with: diagnostics)
                 return currentManifests
             }
 
@@ -1045,6 +1012,23 @@ extension Workspace {
         return (false, [])
     }
 
+    /// Validates that each checked out managed dependency has an entry in pinsStore.
+    private func validatePinsStore(with diagnostics: DiagnosticsEngine) {
+        guard let pinsStore = diagnostics.wrap({ try pinsStore.load() }) else {
+            return
+        }
+
+        for dependency in managedDependencies.values {
+            switch dependency.state {
+            case .checkout: break
+            case .edited: continue
+            }
+            // If we find any checkout that is not in pins store, invoke pin all and return.
+            if pinsStore.pinsMap[dependency.name] == nil {
+                return self.pinAll(pinsStore: pinsStore, diagnostics: diagnostics)
+            }
+        }
+    }
 
     /// This enum represents state of an external package.
     fileprivate enum PackageStateChange {