Resolved review comments.

Author: hartbit

Sources/Workspace/LocalContainerProvider.swift renamed to Sources/Workspace/ResolverPrecomputationProvider.swift

@@ -17,7 +17,7 @@ import SourceControl
 /// PackageContainerProvider implementation used by Workspace to do a dependency pre-calculation using the cached
 /// dependency information (Workspace.DependencyManifests) to check if dependency resolution is required before
 /// performing a full resolution.
-struct LocalContainerProvider: PackageContainerProvider {
+struct ResolverPrecomputationProvider: PackageContainerProvider {
     /// The package graph inputs.
     let root: PackageGraphRoot
 
@@ -65,6 +65,7 @@ struct LocalContainerProvider: PackageContainerProvider {
         }
 
         // Continue searching from the Workspace's root manifests.
+        // FIXME: We might want to use a dictionary for faster lookups.
         if let index = dependencyManifests.root.packageRefs.firstIndex(of: identifier) {
             let container = LocalPackageContainer(
                 manifest: dependencyManifests.root.manifests[index],
@@ -83,10 +84,12 @@ struct LocalContainerProvider: PackageContainerProvider {
 
 private struct LocalPackageContainer: PackageContainer {
     let manifest: Manifest
+    /// The managed dependency if the package is not a root package.
     let dependency: ManagedDependency?
     let config: SwiftPMConfig
     let currentToolsVersion: ToolsVersion
 
+    // Gets the package reference from the managed dependency or computes it for root packages.
     var identifier: PackageReference {
         if let identifier = dependency?.packageRef {
             return identifier
@@ -122,14 +125,29 @@ private struct LocalPackageContainer: PackageContainer {
     }
 
     func getDependencies(at version: Version) throws -> [PackageContainerConstraint] {
+        // Throw an error when the dependency is not at the correct version to fail resolution.
+        guard dependency?.checkoutState?.version == version else {
+            throw Diagnostics.fatalError
+        }
+
         return manifest.dependencyConstraints(config: config)
     }
 
     func getDependencies(at revision: String) throws -> [PackageContainerConstraint] {
+        // Throw an error when the dependency is not at the correct revision to fail resolution.
+        guard dependency?.checkoutState?.revision.identifier == revision else {
+            throw Diagnostics.fatalError
+        }
+
         return manifest.dependencyConstraints(config: config)
     }
 
     func getUnversionedDependencies() throws -> [PackageContainerConstraint] {
+        // Throw an error when the dependency is not unversioned to fail resolution.
+        guard dependency?.state.isCheckout != true else {
+            throw Diagnostics.fatalError
+        }
+
         return manifest.dependencyConstraints(config: config)
     }
 

Sources/Workspace/Workspace.swift

@@ -1429,64 +1429,21 @@ extension Workspace {
             extraConstraints
 
         let diagnostics = DiagnosticsEngine()
-        let localProvider = LocalContainerProvider(
+        let precomputationProvider = ResolverPrecomputationProvider(
              root: root,
              dependencyManifests: dependencyManifests,
              config: config,
              diagnostics: diagnostics
         )
 
-        let resolver = PubgrubDependencyResolver(localProvider)
+        let resolver = PubgrubDependencyResolver(precomputationProvider)
         let result = resolver.solve(dependencies: constraints, pinsStore: pinsStore)
 
-        guard !diagnostics.hasErrors else { return true }
-        guard case .success(let bindings) = result else { return true }
-
-        // Otherwise, check checkouts and pins.
-        for (container, boundVersion) in bindings {
-            let url = container.path
-            let dependencyState = managedDependencies[forURL: url]?.state
-            let pinState = pinsStore.pinsMap[container.identity]?.state
-
-            switch (boundVersion, dependencyState, pinState) {
-            // If the package is excluded, but it is a dependency or a pin, we need to re-resolve.
-            case (.excluded, .some, _),
-                 (.excluded, _, .some):
-                return true
-
-            case (_, .checkout(let checkoutState)?, _):
-                // If this constraint is not same as the checkout state, we need to re-resolve.
-                if boundVersion.description != checkoutState.description {
-                    return true
-                }
-
-                // Ensure that the pin is not out of sync.
-                if checkoutState != pinState {
-                    return true
-                }
-
-            // We have a local package but the requirement is now different.
-            case (.version, .local?, _),
-                 (.revision, .local?, _):
-                return true
-
-            case (.unversioned, .local?, _):
-                continue
-
-            case (_, .edited?, _):
-                continue
-
-            case (_, nil, _):
-                // Ignore root packages.
-                if root.packageRefs.contains(container) {
-                    continue
-                }
-                // We don't have a checkout.
-                return true
-            }
+        if !diagnostics.hasErrors, case .success = result {
+            return false
+        } else {
+            return true
         }
-
-        return false
     }
 
     /// Validates that each checked out managed dependency has an entry in pinsStore.